Rust

[dependencies]
typecast-rust = "0.3.10"
tokio = { version = "1", features = ["full"] }

cargo add typecast-rust tokio --features tokio/full

use typecast_rust::{TypecastClient, TTSRequest, TTSModel};
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client (reads TYPECAST_API_KEY from environment)
    let client = TypecastClient::from_env()?;

    // Convert text to speech
    let request = TTSRequest::new(
        "tc_672c5f5ce59fac2a48faeaee",
        "Hello there! I'm your friendly text-to-speech agent.",
        TTSModel::SsfmV30,
    );

    let response = client.text_to_speech(&request).await?;

    // Save audio file
    fs::write("output.wav", &response.audio_data)?;

    println!(
        "Audio saved! Duration: {:.2}s, Format: {:?}",
        response.duration, response.format
    );

    Ok(())
}

let voices = client
    .recommend_voices("warm female voice for a product tutorial", Some(3))
    .await?;

for voice in voices {
    println!("{} {} {}", voice.voice_id, voice.voice_name, voice.score);
}

use typecast_rust::{TypecastClient, ClientConfig};
use std::time::Duration;

// Using environment variable (recommended)
// export TYPECAST_API_KEY="your-api-key-here"
let client = TypecastClient::from_env()?;

// Or pass directly
let client = TypecastClient::with_api_key("your-api-key-here")?;

// Or with custom configuration
let config = ClientConfig::new("your-api-key-here")
    .base_url("https://api.typecast.ai")
    .timeout(Duration::from_secs(120));

let client = TypecastClient::new(config)?;

let config = ClientConfig::new("")
    .base_url("https://your-proxy.example.com");

let client = TypecastClient::new(config)?;

TYPECAST_API_KEY=your-api-key-here

use typecast_rust::{TTSRequest, TTSModel, Output, AudioFormat};

let request = TTSRequest::new(
    "tc_672c5f5ce59fac2a48faeaee",
    "Customized audio output!",
    TTSModel::SsfmV30,
)
.output(
    Output::new()
        .target_lufs(-14.0)                 // Range: -70 to 0 (LUFS)
        .audio_pitch(2)                   // Range: -12 to +12 semitones
        .audio_tempo(1.2)                 // Range: 0.5x to 2.0x
        .audio_format(AudioFormat::Mp3)   // Options: Wav, Mp3
)
.seed(42);  // Unsigned seed for reproducible results

let response = client.text_to_speech(&request).await?;

fs::write("output.mp3", &response.audio_data)?;
println!("Duration: {:.2}s, Format: {:?}", response.duration, response.format);

client.generate_to_file(
    "output.mp3",
    GenerateToFileRequest::new("tc_672c5f5ce59fac2a48faeaee", "Hello from Typecast."), // Find voice IDs at https://studio.typecast.ai/developers/api/voices
).await?;

let audio = client
    .compose_speech()
    .defaults(ComposerSettings::new().voice_id("tc_672c5f5ce59fac2a48faeaee").model(TtsModel::SsfmV30))
    .say("Hello<|5s|>Nice to meet you<|1s|>Today<|2s|>how does the weather feel?")
    .generate()
    .await?;

use typecast_rust::{ComposerSettings, Output, TTSModel, TypecastClient};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = TypecastClient::new("YOUR_API_KEY")?;
    let audio = client
        .compose_speech()
        .defaults(ComposerSettings::new().voice_id("tc_672c5f5ce59fac2a48faeaee").model(TTSModel::SSFM_V30))
        .say("Hello there")
        .pause(5.0)
        .say_with(
            "Nice to meet you",
            ComposerSettings::new().voice_id("tc_60e5426de8b95f1d3000d7b5").output(Output { audio_pitch: Some(2), ..Default::default() }),
        )
        .say("Today")
    .pause(2)
    .say("How does the weather feel?")
        .generate()
        .await?;

    std::fs::write("conversation.wav", audio.audio_data)?;
    Ok(())
}

use typecast_rust::{TypecastClient, VoicesV2Filter, TTSModel, Gender, Age};

// Get all voices
let voices = client.get_voices_v2(None).await?;

// Filter by criteria
let filter = VoicesV2Filter::new()
    .model(TTSModel::SsfmV30)
    .gender(Gender::Female)
    .age(Age::YoungAdult);

let filtered = client.get_voices_v2(Some(filter)).await?;

// Display voice info
for voice in &voices {
    println!("ID: {}, Name: {}", voice.voice_id, voice.voice_name);
    println!("Gender: {:?}, Age: {:?}", voice.gender, voice.age);
    
    for model in &voice.models {
        println!("Model: {:?}, Emotions: {:?}", model.version, model.emotions);
    }
    
    if let Some(use_cases) = &voice.use_cases {
        println!("Use cases: {}", use_cases.join(", "));
    }
}

// Get a specific voice by ID
let voice = client.get_voice_v2("tc_672c5f5ce59fac2a48faeaee").await?;
println!("Voice: {} ({:?})", voice.voice_name, voice.gender);

// Auto-detect language (recommended)
let request = TTSRequest::new(
    "tc_672c5f5ce59fac2a48faeaee",
    "こんにちは。お元気ですか。",
    TTSModel::SsfmV30,
);

let response = client.text_to_speech(&request).await?;

// Or specify language explicitly
let korean_request = TTSRequest::new(
    "tc_672c5f5ce59fac2a48faeaee",
    "안녕하세요. 반갑습니다.",
    TTSModel::SsfmV30,
)
.language("kor");  // ISO 639-3 language code

let korean_response = client.text_to_speech(&korean_request).await?;

// Stream and extract raw PCM (skip 44-byte WAV header)
let mut stream = client.text_to_speech_stream(&request).await?;
let mut first = true;

while let Some(chunk) = stream.next().await {
    let bytes = chunk?;
    let pcm = if first {
        first = false;
        &bytes[44..]  // Skip WAV header
    } else {
        &bytes
    };
    // pcm is raw 16-bit mono PCM at 32000 Hz
    // Feed to your audio output (e.g. rodio, cpal)
}

use typecast_rust::{TypecastClient, TTSRequestWithTimestamps, TTSModel};
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = TypecastClient::from_env()?;

    let request = TTSRequestWithTimestamps::new(
        "tc_60e5426de8b95f1d3000d7b5",
        "Hello. How are you?",
        TTSModel::SsfmV30,
    );

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

    fs::write("output.wav", result.audio_bytes())?;
    println!("Duration: {:.3}s", result.audio_duration);

    for word in &result.words {
        println!("  [{:.3}s – {:.3}s] {}", word.start_time, word.end_time, word.text);
    }

    Ok(())
}

use typecast_rust::Granularity;

let request = TTSRequestWithTimestamps::new(
    "tc_60e5426de8b95f1d3000d7b5",
    "Hello. How are you?",
    TTSModel::SsfmV30,
)
.granularity(Granularity::Char);  // required for Japanese / Chinese

fs::write("output.srt", result.to_srt())?;
fs::write("output.vtt", result.to_vtt())?;

use typecast_rust::{TypecastClient, TTSModel, TTSRequest};

let client = TypecastClient::from_env()?;
let audio = std::fs::read("sample.wav")?;

let voice = client
    .clone_voice(audio, "sample.wav", "My Voice", "ssfm-v30")
    .await?;

let request = TTSRequest::new(
    &voice.voice_id,
    "Hello from my cloned voice!",
    TTSModel::SsfmV30,
);

let response = client.text_to_speech(&request).await?;
std::fs::write("output.wav", &response.audio_data)?;
client.delete_voice(&voice.voice_id).await?;

use typecast_rust::{TypecastClient, TTSRequest, TTSModel, TypecastError};

let request = TTSRequest::new("voice_id", "Hello", TTSModel::SsfmV30);

match client.text_to_speech(&request).await {
    Ok(response) => {
        println!("Success! Duration: {:.2}s", response.duration);
    }
    Err(TypecastError::Unauthorized { detail }) => {
        // 401: Invalid API key
        eprintln!("Invalid API key: {}", detail);
    }
    Err(TypecastError::PaymentRequired { detail }) => {
        // 402: Insufficient credits
        eprintln!("Insufficient credits: {}", detail);
    }
    Err(TypecastError::NotFound { detail }) => {
        // 404: Resource not found
        eprintln!("Voice not found: {}", detail);
    }
    Err(TypecastError::RateLimited { detail }) => {
        // 429: Rate limit exceeded
        eprintln!("Rate limit exceeded - please retry later: {}", detail);
    }
    Err(TypecastError::ServerError { detail }) => {
        // 500: Server error
        eprintln!("Server error: {}", detail);
    }
    Err(e) => {
        eprintln!("Error: {}", e);
    }
}

if let Err(e) = result {
    if e.is_unauthorized() {
        println!("Check your API key");
    } else if e.is_rate_limited() {
        println!("Wait and retry");
    } else if e.is_server_error() {
        println!("Server issue, try again later");
    }
    
    if let Some(code) = e.status_code() {
        println!("HTTP status: {}", code);
    }
}

use typecast_rust::{
    TypecastClient, TTSRequest, TTSModel, PresetPrompt, 
    EmotionPreset, Output, AudioFormat, VoicesV2Filter, Gender,
};
use std::fs;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Initialize client
    let client = TypecastClient::from_env()?;
    
    // Discover voices
    let filter = VoicesV2Filter::new()
        .model(TTSModel::SsfmV30)
        .gender(Gender::Female);
    
    let voices = client.get_voices_v2(Some(filter)).await?;
    println!("Found {} female voices", voices.len());
    
    // Use first voice
    if let Some(voice) = voices.first() {
        let request = TTSRequest::new(
            &voice.voice_id,
            "Welcome to Typecast! This is a demonstration of our text-to-speech API.",
            TTSModel::SsfmV30,
        )
        .language("eng")
        .prompt(
            PresetPrompt::new()
                .emotion_preset(EmotionPreset::Happy)
                .emotion_intensity(1.2)
        )
        .output(
            Output::new()
                .target_lufs(-14.0)
                .audio_format(AudioFormat::Mp3)
        );
        
        let response = client.text_to_speech(&request).await?;
        
        fs::write("welcome.mp3", &response.audio_data)?;
        println!("Saved welcome.mp3 ({:.2}s)", response.duration);
    }
    
    Ok(())
}