wSocket Rust SDK

https://github.com/wsocket-io/sdk-rust
Admin
The official Rust SDK for wSocket, providing real-time pub/sub messaging over WebSockets with...
Tokens:6,333
Snippets:45
Trust Score:2.7
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install wSocket Rust SDK

Source: https://github.com/wsocket-io/sdk-rust/blob/main/README.md

Add the wsocket-io crate to your project's Cargo.toml file to include the SDK. This is the primary step for integrating wSocket functionality into your Rust application.

```toml
[dependencies]
wsocket-io = "0.1.0"

```

--------------------------------

### Complete Real-Time Chat Application Example (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Demonstrates a full-featured real-time chat application using wSocket. Includes channel subscription, presence tracking, message publishing, and history retrieval. Requires the wsocket_io client and serde_json.

```rust
use wsocket_io::{Client, HistoryOptions, PresenceMember};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let room = client.pubsub.channel("chat:room1").await;

    // Setup presence tracking
    room.presence().on_enter(|m: PresenceMember| {
        println!("→ {} joined the room", m.data["name"]);
    }).await;

    room.presence().on_leave(|m: PresenceMember| {
        println!("← {} left the room", m.data["name"]);
    }).await;

    // Subscribe to messages
    room.subscribe(|data, meta| {
        let user = data["user"].as_str().unwrap_or("unknown");
        let text = data["text"].as_str().unwrap_or("");
        println!("[{}] {}: {}", meta.timestamp, user, text);
    }).await;

    // Load message history
    room.on_history(|result| {
        println!("--- History ({} messages) ---", result.messages.len());
        for msg in result.messages {
            println!("  {}: {}", msg.publisher_id, msg.data);
        }
        println!("--- End History ---");
    }).await;

    room.history(HistoryOptions {
        limit: Some(20),
        ..Default::default()
    }).await;

    // Enter the room
    room.presence().enter(json!({
        "name": "Alice",
        "avatar": "https://example.com/alice.png"
    })).await;

    // Send a message
    room.publish(json!({
        "user": "Alice",
        "text": "Hello everyone!"
    })).await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Get Channel Presence Members List (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Requests the current list of members present in a channel. The results are delivered via the `on_members` callback. Requires `wsocket_io` and `serde_json` crates.

```rust
use wsocket_io::{Client, PresenceMember};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    // Register callback to receive members list
    chat.presence().on_members(|members: Vec<PresenceMember>| {
        println!("Current members in channel:");
        for member in members {
            println!("  - {} (joined at {})", member.client_id, member.joined_at);
            println!("    Data: {}", member.data);
        }
    }).await;

    // Request the members list
    chat.presence().get().await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Build and Test wSocket Rust SDK Project

Source: https://github.com/wsocket-io/sdk-rust/blob/main/README.md

Standard Rust development commands for building the project and running tests. Assumes the project is set up with Cargo. These commands are essential for local development and verification.

```bash
cargo build
cargo test

```

--------------------------------

### Connect and Publish Messages with wSocket Rust SDK

Source: https://github.com/wsocket-io/sdk-rust/blob/main/README.md

Demonstrates connecting to a wSocket server, subscribing to a channel, and publishing a JSON message. Requires the 'tokio' runtime and 'serde_json' for message serialization. Handles asynchronous operations.

```rust
use wsocket_io::Client;

#[tokio::main]
async fn main() {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key")
        .await
        .unwrap();

    let chat = client.channel("chat:general").await;

    chat.subscribe(|data, meta| {
        println!("[{{}}] {{}}", meta.channel, data);
    }).await;

    chat.publish(serde_json::json!({"text": "Hello from Rust!"})).await;

    client.wait().await;
}

```

--------------------------------

### Push Client Initialization

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Initializes the `PushClient` for REST-based push notification capabilities, usable standalone or configured via the WebSocket client.

```APIDOC
## PushClient::new

### Description
Initializes a new `PushClient` instance for managing push notifications via REST API.

### Method
Constructor

### Endpoint
N/A (Client-side initialization)

### Parameters
- **base_url** (string) - Required - The base URL for the push notification API (e.g., `"https://api.wsocket.io"`).
- **admin_token** (string) - Required - The authentication token for administrative access.
- **app_id** (string) - Required - The unique identifier for the application.

### Request Example
```rust
use wsocket_io::PushClient;

let push = PushClient::new(
    "https://api.wsocket.io",
    "your-admin-token",
    "your-app-id"
);
```

### Response
#### Success Response
A `PushClient` instance is created.

#### Response Example
(No direct response, but the `push` object is ready for use.)
```

--------------------------------

### Handle Presence Event Callbacks (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Sets up callbacks for real-time presence events: `on_enter` for new members, `on_leave` for departing members, and `on_update` for data changes. Requires `wsocket_io` and `serde_json` crates.

```rust
use wsocket_io::{Client, PresenceMember};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    // Track when users join
    chat.presence().on_enter(|member: PresenceMember| {
        println!("User joined: {} with data: {}", member.client_id, member.data);
    }).await;

    // Track when users leave
    chat.presence().on_leave(|member: PresenceMember| {
        println!("User left: {}", member.client_id);
    }).await;

    // Track when users update their presence data
    chat.presence().on_update(|member: PresenceMember| {
        println!("User {} updated: {}", member.client_id, member.data);
    }).await;

    // Enter the channel ourselves
    chat.presence().enter(json!({"name": "Observer"})).await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Manage Presence with wSocket Rust SDK

Source: https://github.com/wsocket-io/sdk-rust/blob/main/README.md

Shows how to manage channel presence, including subscribing to enter/leave events and entering presence information. Uses JSON for presence data. Requires an active client connection.

```rust
let chat = client.channel("chat:general").await;

chat.presence().on_enter(|m| {
    println!("joined: {{}}", m.client_id);
}).await;

chat.presence().on_leave(|m| {
    println!("left: {{}}", m.client_id);
}).await;

chat.presence().enter(serde_json::json!({"name": "Alice"})).await;
let members = chat.presence().get().await;

```

--------------------------------

### Connect to wSocket Server (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Establishes a WebSocket connection to a wSocket server using an API key. The `Client::connect` method returns an `Arc<Client>` for safe sharing across async tasks and handles keepalive messages automatically. This is essential for initiating communication.

```rust
use wsocket_io::Client;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to wSocket server with API key authentication
    let client: Arc<Client> = Client::connect(
        "wss://node00.wsocket.online",
        "your-api-key"
    ).await?;

    println!("Connected to wSocket server!");

    // Keep the connection alive until server disconnects
    client.wait().await;

    Ok(())
}

```

--------------------------------

### Enter Channel Presence with User Data (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Announces the client's presence in a channel, optionally including user metadata. This action triggers `on_enter` callbacks for other subscribers. Requires the `wsocket_io` and `serde_json` crates.

```rust
use wsocket_io::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    // Enter the presence set with user metadata
    chat.presence().enter(json!({
        "name": "Alice",
        "avatar": "https://example.com/alice.png",
        "status": "online"
    })).await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Initialize Push Client for REST Notifications in Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Initializes the `PushClient` for sending REST-based push notifications. This client can be used independently or configured through an existing WebSocket client via `configure_push`.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create standalone push client
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    println!("Push client initialized");
    Ok(())
}
```

--------------------------------

### Broadcast Push Notification to All Users (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Broadcasts a push notification to all registered devices across the application. Useful for global announcements. Requires the PushClient, admin token, and app ID. Outputs a success or error result.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    // Broadcast to all app subscribers
    let result = push.broadcast(
        "System Maintenance",
        Some("The service will be down for maintenance at 2:00 AM UTC")
    ).await?;

    println!("Broadcast sent: {}", result);
    Ok(())
}
```

--------------------------------

### Publish Message to Channel (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Publishes a JSON message to a channel, making it available to all subscribers. Messages are persisted by default for history retrieval. `publish_with_opts` allows control over persistence.

```rust
use wsocket_io::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    // Publish a message (persisted by default)
    chat.publish(json!({
        "text": "Hello from Rust!",
        "user": "alice",
        "timestamp": 1699900000
    })).await;

    // Publish without persisting to history
    chat.publish_with_opts(json!({
        "type": "typing",
        "user": "alice"
    }), false).await;

    client.wait().await;
    Ok(())
}

```

--------------------------------

### Retrieve Message History with wSocket Rust SDK

Source: https://github.com/wsocket-io/sdk-rust/blob/main/README.md

Demonstrates how to retrieve message history from a channel using specified options. Requires the 'wsocket-io' crate and associated types like 'HistoryOptions'. Processes historical messages in a loop.

```rust
chat.on_history(|result| {
    for msg in &result.messages {
        println!("[{{}}] {{}}", msg.timestamp, msg.data);
    }
}).await;

chat.history(HistoryOptions { limit: Some(50), ..Default::default() }).await;

```

--------------------------------

### Subscribe to Channel (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Subscribes to a specific channel and registers a callback function to process incoming messages. The callback receives message data and metadata, including ID, channel, and timestamp. This enables real-time message handling for features like chat.

```rust
use wsocket_io::{Client, MessageMeta};
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    // Get a channel reference
    let chat = client.pubsub.channel("chat:general").await;

    // Subscribe to receive messages
    chat.subscribe(|data: Value, meta: MessageMeta| {
        println!("Message ID: {}", meta.id);
        println!("Channel: {}", meta.channel);
        println!("Timestamp: {}", meta.timestamp);
        println!("Data: {}", data);
    }).await;

    client.wait().await;
    Ok(())
}

```

--------------------------------

### Message History Query

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Retrieves persisted messages from a channel using `HistoryOptions` for pagination. Results are delivered via the `on_history` callback.

```APIDOC
## GET /channels/{channel_id}/history

### Description
Retrieves persisted messages from a specified channel. Supports pagination and filtering via query parameters.

### Method
GET

### Endpoint
`/channels/{channel_id}/history`

### Query Parameters
- **limit** (integer) - Optional - The maximum number of messages to retrieve.
- **before** (integer) - Optional - Timestamp (in milliseconds) to fetch messages before.
- **after** (integer) - Optional - Timestamp (in milliseconds) to fetch messages after.
- **direction** (string) - Optional - Direction of fetching ('backward' or 'forward'). Defaults to 'backward'.

### Response
#### Success Response (200)
- **channel** (string) - The channel ID from which messages were retrieved.
- **has_more** (boolean) - Indicates if there are more messages available beyond the current result set.
- **messages** (array) - An array of message objects.
  - **timestamp** (integer) - The timestamp of the message.
  - **publisher_id** (string) - The ID of the user who published the message.
  - **data** (string) - The content of the message.

#### Response Example
```json
{
  "channel": "chat:general",
  "has_more": true,
  "messages": [
    {
      "timestamp": 1699900000000,
      "publisher_id": "user123",
      "data": "Hello everyone!"
    }
  ]
}
```
```

--------------------------------

### Query Message History with Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Retrieves persisted messages from a channel using the `history` method. `HistoryOptions` allow control over pagination via `limit`, `before`, `after`, and `direction`. Results are received through the `on_history` callback.

```rust
use wsocket_io::{Client, HistoryOptions, HistoryResult};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    // Register callback to receive history results
    chat.on_history(|result: HistoryResult| {
        println!("Channel: {}", result.channel);
        println!("Has more: {}", result.has_more);
        println!("Messages ({}):", result.messages.len());

        for msg in &result.messages {
            println!("  [{}] {} - {}", msg.timestamp, msg.publisher_id, msg.data);
        }
    }).await;

    // Query last 50 messages
    chat.history(HistoryOptions {
        limit: Some(50),
        ..Default::default()
    }).await;

    // Query messages before a specific timestamp
    chat.history(HistoryOptions {
        limit: Some(20),
        before: Some(1699900000000),
        direction: Some("backward".to_string()),
        ..Default::default()
    }).await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Send Push Notification to a Specific Member (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Sends a push notification to all registered devices for a specific member ID. Requires the PushClient, admin token, and app ID. Outputs a success or error result.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    // Send push notification to a specific user
    let result = push.send_to_member(
        "user123",
        "New Message",
        Some("You have a new message from Alice")
    ).await?;

    println!("Push sent: {}", result);
    Ok(())
}
```

--------------------------------

### Subscribe with Rewind (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Subscribes to a channel and automatically fetches a specified number of recent historical messages. This is useful for clients to catch up on missed messages upon reconnection, ensuring data continuity.

```rust
use wsocket_io::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let notifications = client.pubsub.channel("notifications:user123").await;

    // Subscribe and receive the last 10 messages
    notifications.subscribe_with_rewind(|data, meta| {
        println!("[{}] Notification: {}", meta.timestamp, data);
    }, 10).await;

    client.wait().await;
    Ok(())
}

```

--------------------------------

### Push: Register FCM Device (Android)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Registers an Android device's Firebase Cloud Messaging token with a member ID for targeted push notifications.

```APIDOC
## POST /push/register/fcm

### Description
Registers an Android device's FCM token for push notifications, associating it with a specific member ID.

### Method
POST

### Endpoint
`/push/register/fcm`

### Parameters
#### Request Body
- **fcm_token** (string) - Required - The FCM device token obtained from Firebase.
- **member_id** (string) - Required - The identifier of the member to associate the device with.

### Request Example
```json
{
  "fcm_token": "fcm-device-token-from-firebase",
  "member_id": "user123"
}
```

### Response
#### Success Response (200)
- **subscription_id** (string) - The unique identifier for the newly created push subscription.

#### Response Example
```json
{
  "subscription_id": "sub_abc123xyz"
}
```
```

--------------------------------

### Push: Register APNs Device (iOS)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Registers an iOS device's Apple Push Notification service token with a member ID for targeted push notifications.

```APIDOC
## POST /push/register/apns

### Description
Registers an iOS device's APNs token for push notifications, associating it with a specific member ID.

### Method
POST

### Endpoint
`/push/register/apns`

### Parameters
#### Request Body
- **apns_token** (string) - Required - The APNs device token obtained from Apple.
- **member_id** (string) - Required - The identifier of the member to associate the device with.

### Request Example
```json
{
  "apns_token": "apns-device-token-from-apple",
  "member_id": "user456"
}
```

### Response
#### Success Response (200)
- **subscription_id** (string) - The unique identifier for the newly created push subscription.

#### Response Example
```json
{
  "subscription_id": "sub_def456uvw"
}
```
```

--------------------------------

### Leave Channel Presence (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Removes the current client from a channel's presence set, triggering `on_leave` callbacks for other subscribers. This method is used for graceful disconnection from the presence tracking.

```rust
use wsocket_io::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    chat.presence().enter(json!({"name": "Alice"})).await;

    // Gracefully leave the presence set
    chat.presence().leave().await;
    println!("Left the channel presence");

    Ok(())
}
```

--------------------------------

### Register APNs Device for Push Notifications (iOS) in Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Registers an iOS device's Apple Push Notification service (APNs) token with the push notification service. This associates the token with a specific member ID, enabling targeted notifications.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    // Register iOS device for push notifications
    let subscription_id = push.register_apns(
        "apns-device-token-from-apple",
        "user456"
    ).await?;

    println!("Registered APNs device, subscription ID: {}", subscription_id);
    Ok(())
}
```

--------------------------------

### Register FCM Device for Push Notifications (Android) in Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Registers an Android device's Firebase Cloud Messaging (FCM) token with the push notification service. This associates the token with a specific member ID, enabling targeted notifications.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    // Register Android device for push notifications
    let subscription_id = push.register_fcm(
        "fcm-device-token-from-firebase",
        "user123"
    ).await?;

    println!("Registered FCM device, subscription ID: {}", subscription_id);
    Ok(())
}
```

--------------------------------

### Update Presence Data in Channel (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Modifies the client's presence data within a channel without requiring a leave and re-enter action. This updates subscriber information and triggers `on_update` callbacks.

```rust
use wsocket_io::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;

    chat.presence().enter(json!({
        "name": "Alice",
        "status": "online"
    })).await;

    // Update presence status without leaving
    chat.presence().update(json!({
        "name": "Alice",
        "status": "away"
    })).await;

    client.wait().await;
    Ok(())
}
```

--------------------------------

### Push: Unregister Device

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Removes push notification subscriptions for a member, optionally filtering by platform (FCM or APNs).

```APIDOC
## DELETE /push/unregister

### Description
Removes push notification subscriptions for a given member. Can optionally filter by platform.

### Method
DELETE

### Endpoint
`/push/unregister`

### Parameters
#### Query Parameters
- **member_id** (string) - Required - The identifier of the member whose subscriptions are to be removed.
- **platform** (string) - Optional - The platform to unregister ('fcm' for Android, 'apns' for iOS). If omitted, all subscriptions for the member are removed.

### Response
#### Success Response (200)
- **removed_count** (integer) - The number of subscriptions that were successfully removed.

#### Response Example
```json
{
  "removed_count": 5
}
```
```

--------------------------------

### Unsubscribe from Channel (Rust)

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Removes all message callbacks for a specific channel, effectively stopping message reception. This is crucial for resource management and preventing unwanted notifications when a user leaves a channel or context.

```rust
use wsocket_io::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:room1").await;

    chat.subscribe(|data, meta| {
        println!("[{}] {}", meta.channel, data);
    }).await;

    // Later, unsubscribe from the channel
    chat.unsubscribe().await;
    println!("Unsubscribed from chat:room1");

    Ok(())
}

```

--------------------------------

### Gracefully Disconnect WebSocket Client with Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Closes the WebSocket connection cleanly using the `disconnect` method. This action halts all ongoing ping/pong heartbeats and message processing loops.

```rust
use wsocket_io::Client;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::connect("wss://node00.wsocket.online", "your-api-key").await?;

    let chat = client.pubsub.channel("chat:general").await;
    chat.subscribe(|data, _meta| {
        println!("Received: {}", data);
    }).await;

    // Run for 30 seconds then disconnect
    sleep(Duration::from_secs(30)).await;

    client.disconnect().await;
    println!("Disconnected from server");

    Ok(())
}
```

--------------------------------

### Client Disconnect

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Gracefully closes the WebSocket connection, stopping all ping/pong heartbeats and message processing loops.

```APIDOC
## POST /disconnect

### Description
Gracefully closes the WebSocket connection established by the client. This action stops all ongoing heartbeats and message processing.

### Method
POST

### Endpoint
`/disconnect`

### Parameters
This endpoint does not require any parameters.

### Response
#### Success Response (200)
Indicates that the disconnection process has been initiated successfully.

#### Response Example
(No specific response body is typically returned for a successful disconnect, often just a status code.)
```

--------------------------------

### Unregister Push Notification Devices in Rust

Source: https://context7.com/wsocket-io/sdk-rust/llms.txt

Removes push notification subscriptions for a given member ID. The `unregister` method can optionally filter by platform (e.g., 'fcm' or 'apns') to remove specific types of subscriptions.

```rust
use wsocket_io::PushClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let push = PushClient::new(
        "https://api.wsocket.io",
        "your-admin-token",
        "your-app-id"
    );

    // Unregister all devices for a member
    let removed = push.unregister("user123", None).await?;
    println!("Removed {} subscriptions", removed);

    // Unregister only Android devices
    let removed = push.unregister("user456", Some("fcm")).await?;
    println!("Removed {} FCM subscriptions", removed);

    Ok(())
}
```
Tokens:
Raw