curl -X POST "https://api.wasend.dev/sessions/SESSION_ID/restart" \
  -H "Authorization: Bearer YOUR_API_KEY"

import { WasendClient } from '@wasend/core';

const client = new WasendClient({
  apiKey: 'YOUR_API_KEY',
  baseUrl: 'https://api.wasend.dev'
});

// Restart a session
const session = await client.restartSession('SESSION_ID');
console.log('Restarted session:', session);

const { WasendClient } = require('@wasend/core');

const client = new WasendClient({
  apiKey: 'YOUR_API_KEY',
  baseUrl: 'https://api.wasend.dev'
});

const session = await client.restartSession('SESSION_ID');
console.log('Restarted session:', session);

from wasend import WasendClient

client = WasendClient(
    api_key='YOUR_API_KEY',
    base_url='https://api.wasend.dev'
)

session = client.restart_session('SESSION_ID')
print('Restarted session:', session)

package main

import (
	"fmt"
	"github.com/wasenddev/wasend-sdk-go/wasendcore"
)

func StringPtr(s string) *string    { return &s }
func Float64Ptr(f float64) *float64 { return &f }

func main() {
	client := wasendcore.NewWasendClient(&wasendcore.WasendConfig{
		ApiKey:  StringPtr("YOUR_API_KEY"),
		BaseUrl: StringPtr("https://api.wasend.dev"),
	})

	session := client.RestartSession(StringPtr("SESSION_ID"))
	fmt.Printf("Restarted session: %+v\n", session)
}

using Wasend.Core;

var config = new WasendConfig
{
    ApiKey = "your-api-key-here" // Required
    // BaseUrl and Timeout are optional and have default values
};

var client = new WasendClient(config);
var session = client.RestartSession("your-session-id-here");
Console.WriteLine($"Restarted session: {session}");

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.wasend.dev/sessions/SESSION_ID/restart"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.noBody())
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response: " + response.body());
    }
}

<?php
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://api.wasend.dev/sessions/SESSION_ID/restart");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_KEY"
]);

$response = curl_exec($ch);
curl_close($ch);

echo "Response: " . $response;

require 'net/http'
require 'uri'

uri = URI('https://api.wasend.dev/sessions/SESSION_ID/restart')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts "Response: #{response.body}"

import Foundation

let url = URL(string: "https://api.wasend.dev/sessions/SESSION_ID/restart")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_KEY", forHTTPHeaderField: "Authorization")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print("Response: \(String(data: data, encoding: .utf8) ?? "")")
    }
}
task.resume()

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str("Bearer YOUR_API_KEY")?
    );

    let client = reqwest::Client::new();
    let response = client
        .post("https://api.wasend.dev/sessions/SESSION_ID/restart")
        .headers(headers)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", response);
    Ok(())
}