Rust

[dependencies]
typecast-rust = "0.3.7"
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>> {
    // 클라이언트 초기화 (환경변수에서 TYPECAST_API_KEY 읽기)
    let client = TypecastClient::from_env()?;

    // 텍스트를 음성으로 변환
    let request = TTSRequest::new(
        "tc_672c5f5ce59fac2a48faeaee",
        "안녕하세요! 저는 텍스트 음성 변환 에이전트입니다.",
        TTSModel::SsfmV30,
    );

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

    // 오디오 파일 저장
    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;

// 환경 변수 사용 (권장)
// export TYPECAST_API_KEY="your-api-key-here"
let client = TypecastClient::from_env()?;

// 또는 직접 전달
let client = TypecastClient::with_api_key("your-api-key-here")?;

// 또는 사용자 정의 구성과 함께
let config = ClientConfig::new("your-api-key-here")
    .base_url("https://api.typecast.ai")
    .timeout(Duration::from_secs(120));

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",
    "사용자 정의 오디오 출력!",
    TTSModel::SsfmV30,
)
.output(
    Output::new()
        .target_lufs(-14.0)                 // 범위: -70 ~ 0 (LUFS)
        .audio_pitch(2)                   // 범위: -12 to +12 반음
        .audio_tempo(1.2)                 // 범위: 0.5x to 2.0x
        .audio_format(AudioFormat::Mp3)   // 옵션: Wav, Mp3
)
.seed(42);  // 부호 없는 정수 시드 (재현 가능한 결과)

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", "안녕하세요, 타입캐스트입니다."), // voice_id는 https://typecast.ai/developers/api/voices 에서 확인하세요.
).await?;

let audio = client
    .compose_speech()
    .defaults(ComposerSettings::new().voice_id("tc_672c5f5ce59fac2a48faeaee").model(TtsModel::SsfmV30))
    .say("안녕하세요<|5s|>반갑습니다<|1s|>오늘<|2s|>날씨는 어떤 것 같으세요?")
    .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};

// 모든 음성 가져오기
let voices = client.get_voices_v2(None).await?;

// 기준으로 필터링
let filter = VoicesV2Filter::new()
    .model(TTSModel::SsfmV30)
    .gender(Gender::Female)
    .age(Age::YoungAdult);

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

// 음성 정보 표시
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(", "));
    }
}

// ID로 특정 음성 가져오기
let voice = client.get_voice_v2("tc_672c5f5ce59fac2a48faeaee").await?;
println!("Voice: {} ({:?})", voice.voice_name, voice.gender);

// 언어 자동 감지 (권장)
let request = TTSRequest::new(
    "tc_672c5f5ce59fac2a48faeaee",
    "こんにちは。お元気ですか。",
    TTSModel::SsfmV30,
);

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

// 또는 명시적으로 언어 지정
let korean_request = TTSRequest::new(
    "tc_672c5f5ce59fac2a48faeaee",
    "안녕하세요. 반갑습니다.",
    TTSModel::SsfmV30,
)
.language("kor");  // ISO 639-3 언어 코드

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

// 원시 PCM 추출 (44바이트 WAV 헤더 건너뛰기)
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..]  // WAV 헤더 건너뛰기
    } else {
        &bytes
    };
    // pcm은 32000 Hz 16비트 모노 원시 PCM
    // 오디오 출력으로 전달 (예: rodio, cpal)
}

use typecast::{TypecastClient, models::TTSRequestWithTimestamps};
use std::fs;

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

    let result = client.text_to_speech_with_timestamps(TTSRequestWithTimestamps {
        voice_id: "tc_60e5426de8b95f1d3000d7b5".to_string(),
        text: "Hello. How are you?".to_string(),
        model: "ssfm-v30".to_string(),
        ..Default::default()
    }).await?;

    fs::write("output.wav", result.audio_bytes())?;
    println!("재생 시간: {:.3}초", result.audio_duration);

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

use typecast::models::Granularity;

// 문자 단위 정렬 — 일본어·중국어에 필수
let result = client.text_to_speech_with_timestamps(TTSRequestWithTimestamps {
    voice_id: "tc_60e5426de8b95f1d3000d7b5".to_string(),
    text: "Hello. How are you?".to_string(),
    model: "ssfm-v30".to_string(),
    granularity: Some(Granularity::Char),
    ..Default::default()
}).await?;

let srt = result.to_srt()?;
fs::write("output.srt", srt)?;

let vtt = result.to_vtt()?;
fs::write("output.vtt", vtt)?;

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

let request = TTSRequest::new("voice_id", "안녕하세요", TTSModel::SsfmV30);

match client.text_to_speech(&request).await {
    Ok(response) => {
        println!("Success! Duration: {:.2}s", response.duration);
    }
    Err(TypecastError::Unauthorized { detail }) => {
        // 401: 잘못된 API 키
        eprintln!("Invalid API key: {}", detail);
    }
    Err(TypecastError::PaymentRequired { detail }) => {
        // 402: 크레딧 부족
        eprintln!("Insufficient credits: {}", detail);
    }
    Err(TypecastError::NotFound { detail }) => {
        // 404: 리소스를 찾을 수 없음
        eprintln!("Voice not found: {}", detail);
    }
    Err(TypecastError::RateLimited { detail }) => {
        // 429: 요청 한도 초과
        eprintln!("Rate limit exceeded - please try again later: {}", detail);
    }
    Err(TypecastError::ServerError { detail }) => {
        // 500: 서버 오류
        eprintln!("Server error: {}", detail);
    }
    Err(e) => {
        eprintln!("Error: {}", e);
    }
}

if let Err(e) = result {
    if e.is_unauthorized() {
        println!("Please check your API key");
    } else if e.is_rate_limited() {
        println!("Please try again later");
    } else if e.is_server_error() {
        println!("Server issue, please 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>> {
    // 클라이언트 초기화
    let client = TypecastClient::from_env()?;
    
    // 음성 탐색
    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());
    
    // 첫 번째 음성 사용
    if let Some(voice) = voices.first() {
        let request = TTSRequest::new(
            &voice.voice_id,
            "Typecast에 오신 것을 환영합니다! 텍스트 음성 변환 API의 데모입니다.",
            TTSModel::SsfmV30,
        )
        .language("kor")
        .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!("welcome.mp3 saved ({:.2}s)", response.duration);
    }
    
    Ok(())
}