Skip to content

Latest commit

 

History

History
5528 lines (4176 loc) · 89.3 KB

reference.md

File metadata and controls

5528 lines (4176 loc) · 89.3 KB

Reference

client.get_swagger_docs_docs_get() -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client.get_swagger_docs_docs_get(None).await;
}
client.get_redoc_docs_redocs_get() -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client.get_redoc_docs_redocs_get(None).await;
}
client.get_openapi_schema_openapi_json_get() -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client.get_openapi_schema_openapi_json_get(None).await;
}

AudioSeparation

client.audio_separation.create_audio_separation(run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineCallResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .audio_separation
        .create_audio_separation(
            &CreateAudioSeparationRequest {
                media_file: b"test file content".to_vec(),
                project_name: None,
                project_description: None,
                folder_id: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.audio_separation.get_audio_separation_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .audio_separation
        .get_audio_separation_status(
            &"task_id".to_string(),
            &GetAudioSeparationStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.audio_separation.get_audio_separation_run_info(run_id: Option<i64>) -> Result<GetAudioSeparationResultOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .audio_separation
        .get_audio_separation_run_info(&Some(1), None)
        .await;
}

⚙️ Parameters

run_id: Option<i64>

client.audio_separation.get_audio_separation_runs_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, GetAudioSeparationResultOut>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .audio_separation
        .get_audio_separation_runs_results(
            &GetAudioSeparationRunsResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

Dub

client.dub.end_to_end_dubbing(request: EndToEndDubbingRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineCallResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .end_to_end_dubbing(
            &EndToEndDubbingRequestPayload {
                video_url: "video_url".to_string(),
                source_language: Languages(1),
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                target_language: None,
                target_languages: None,
                selected_audio_tracks: None,
                add_output_as_an_audio_track: None,
                chosen_dictionaries: None,
                ai_optimization: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

video_url: String

source_language: Languages

target_language: Option<Option<Languages>>

target_languages: Option<Option<Vec<Languages>>>

selected_audio_tracks: Option<Option<Vec<i64>>>

add_output_as_an_audio_track: Option<Option<bool>>

chosen_dictionaries: Option<Option<Vec<i64>>>

ai_optimization: Option<Option<bool>>

run_id: Option<Option<i64>>

client.dub.get_end_to_end_dubbing_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .get_end_to_end_dubbing_status(
            &"task_id".to_string(),
            &GetEndToEndDubbingStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.dub.get_dubbed_run_info(run_id: Option<i64>) -> Result<GetDubbedRunInfoDubResultRunIDGetResponse, ApiError>

📝 Description

NOTE: This endpoint should be called only by the users to get values for their runs via API. Further we need to validate if the user has access to the run_id, otherwise we should not return the output urls.

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client.dub.get_dubbed_run_info(&Some(1), None).await;
}

⚙️ Parameters

run_id: Option<i64>

client.dub.get_dubbing_runs_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, GetDubbingRunsResultsDubbingResultsPostResponseValue>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .get_dubbing_runs_results(
            &GetDubbingRunsResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.dub.get_dubbed_run_transcript(run_id: Option<i64>, language: Languages, format_type: Option<Option<TranscriptFileFormat>>, data_type: Option<Option<TranscriptDataType>>) -> Result<std::collections::HashMap<String, String>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .get_dubbed_run_transcript(
            &Some(1),
            &Languages(1),
            &GetDubbedRunTranscriptQueryRequest {
                format_type: None,
                data_type: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

language: Languages

format_type: Option<TranscriptFileFormat> — Format to use for the transcription. Either srt, vtt or txt. Defaults to txt.

data_type: Option<TranscriptDataType> — Data type for the transcription being returned. Returns the raw data of the transcription or a presigned url for the file that holds the transcription data.

client.dub.get_dubbed_output_in_alt_format(run_id: Option<i64>, language: Languages, request: DubbedOutputInAltFormatRequestPayload) -> Result<GetDubbedOutputInAltFormatDubAltFormatRunIDLanguagePostResponse, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .get_dubbed_output_in_alt_format(
            &Some(1),
            &Languages(1),
            &DubbedOutputInAltFormatRequestPayload {
                output_format: DubbedOutputInAltFormatRequestPayloadOutputFormat::AudioOutputType(
                    AudioOutputType::Flac,
                ),
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

language: Languages

output_format: DubbedOutputInAltFormatRequestPayloadOutputFormat

client.dub.get_dubbed_output_in_alt_format_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .get_dubbed_output_in_alt_format_status(
            &"task_id".to_string(),
            &GetDubbedOutputInAltFormatStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.dub.poll_discord_dub_task(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .poll_discord_dub_task(
            &"task_id".to_string(),
            &PollDiscordDubTaskQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.dub.poll_twitter_dub_task(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dub
        .poll_twitter_dub_task(
            &"task_id".to_string(),
            &PollTwitterDubTaskQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

Folders

client.folders.list_folders(limit: Option<Option<Option<i64>>>, search_query: Option<Option<Option<String>>>, run_id: Option<Option<Option<i64>>>) -> Result<Vec<Folder>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .folders
        .list_folders(
            &ListFoldersQueryRequest {
                limit: None,
                search_query: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

limit: Option<Option<i64>>

search_query: Option<Option<String>>

run_id: Option<Option<i64>>

client.folders.create_folder(request: CreateFolderPayload, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .folders
        .create_folder(
            &CreateFolderPayload {
                folder_name: "folder_name".to_string(),
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

folder_name: String

run_id: Option<Option<i64>>

Languages

client.languages.get_source_languages(run_id: Option<Option<Option<i64>>>) -> Result<Vec<LanguagePydanticModel>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .languages
        .get_source_languages(&GetSourceLanguagesQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.languages.get_target_languages(run_id: Option<Option<Option<i64>>>) -> Result<Vec<LanguagePydanticModel>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .languages
        .get_target_languages(&GetTargetLanguagesQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

Story

client.story.create_story(run_id: Option<Option<Option<i64>>>) -> Result<CreateStoryStoryPostResponse, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .story
        .create_story(
            &CreateStoryRequest {
                file: b"test file content".to_vec(),
                source_language: Languages(1),
                title: None,
                description: None,
                narrator_voice_id: None,
                folder_id: None,
                chosen_dictionaries: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.story.setup_story(run_id: Option<Option<Option<i64>>>) -> Result<SetupStoryStorySetupPostResponse, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .story
        .setup_story(
            &SetupStoryRequest {
                file: b"test file content".to_vec(),
                source_language: Languages(1),
                title: None,
                description: None,
                narrator_voice_id: None,
                folder_id: None,
                chosen_dictionaries: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.story.get_story_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .story
        .get_story_status(
            &"task_id".to_string(),
            &GetStoryStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.story.get_story_run_info(run_id: Option<i64>, include_transcript: Option<Option<Option<bool>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .story
        .get_story_run_info(
            &Some(1),
            &GetStoryRunInfoQueryRequest {
                include_transcript: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

include_transcript: Option<Option<bool>> — Whether to include the transcription in the response for fetching the result of a Stories run.

client.story.get_stories_runs_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, std::collections::HashMap<String, serde_json::Value>>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .story
        .get_stories_runs_results(
            &GetStoriesRunsResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

TranslatedStory

client.translated_story.create_translation_for_existing_story(run_id: Option<i64>, request: CreateTranslationForExistingStoryRequestPayload) -> Result<AddTargetLanguageOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translated_story
        .create_translation_for_existing_story(
            &Some(1),
            &CreateTranslationForExistingStoryRequestPayload {
                target_language: Languages(1),
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

target_language: Languages

client.translated_story.get_translated_story_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translated_story
        .get_translated_story_status(
            &"task_id".to_string(),
            &GetTranslatedStoryStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.translated_story.get_translated_story_run_info(run_id: Option<i64>, target_language: Languages, include_transcript: Option<Option<Option<bool>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translated_story
        .get_translated_story_run_info(
            &Some(1),
            &Languages(1),
            &GetTranslatedStoryRunInfoQueryRequest {
                include_transcript: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

target_language: Languages

include_transcript: Option<Option<bool>> — Whether to include the transcription in the response for fetching the result of a Stories Translation run.

TextToAudio

client.text_to_audio.create_text_to_audio(request: CreateTextToAudioRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineCallResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_audio
        .create_text_to_audio(
            &CreateTextToAudioRequestPayload {
                prompt: "prompt".to_string(),
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                duration: None,
                audio_type: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

prompt: String — The text to be converted to audio.

duration: Option<f64> — The desired duration of the audio.

audio_type: Option<TextToAudioType> — The audio type preference.

run_id: Option<Option<i64>>

client.text_to_audio.get_text_to_audio_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_audio
        .get_text_to_audio_status(
            &"task_id".to_string(),
            &GetTextToAudioStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.text_to_audio.get_text_to_sound_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, TextToAudioResult>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_audio
        .get_text_to_sound_results(
            &GetTextToSoundResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

TextToVoice

client.text_to_voice.create_text_to_voice(request: CreateTextToVoiceRequestPayload) -> Result<OrchestratorPipelineCallResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_voice
        .create_text_to_voice(
            &CreateTextToVoiceRequestPayload {
                text: "text".to_string(),
                voice_description: "voice_description".to_string(),
                project_name: None,
                project_description: None,
                folder_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

text: String — The text to be converted to voice

voice_description: String — Description to use for the created voice

client.text_to_voice.get_text_to_voice_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_voice
        .get_text_to_voice_status(
            &"task_id".to_string(),
            &GetTextToVoiceStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.text_to_voice.get_text_to_voice_result(run_id: Option<i64>) -> Result<GetTextToVoiceResultOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_voice
        .get_text_to_voice_result(&Some(1), None)
        .await;
}

⚙️ Parameters

run_id: Option<i64>

TextToSpeech

client.text_to_speech.tts(request: CreateStreamTtsRequestPayload) -> Result<Vec<u8>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .tts(
            &CreateStreamTtsRequestPayload {
                text: "foo".to_string(),
                language: CreateStreamTtsRequestPayloadLanguage::ArKw,
                voice_id: 1,
                speech_model: None,
                user_instructions: None,
                enhance_named_entities_pronunciation: None,
                output_configuration: None,
                voice_settings: None,
                inference_options: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

text: String

language: CreateStreamTtsRequestPayloadLanguage

voice_id: i64

speech_model: Option<CreateStreamTtsRequestPayloadSpeechModel>

user_instructions: Option<Option<String>>

enhance_named_entities_pronunciation: Option<bool>

output_configuration: Option<StreamTtsOutputConfiguration>

voice_settings: Option<StreamTtsVoiceSettings>

inference_options: Option<StreamTtsInferenceOptions>

client.text_to_speech.create_tts(request: CreateTtsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<CreateTtsOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .create_tts(
            &CreateTtsRequestPayload {
                text: "text".to_string(),
                voice_id: 1,
                language: Languages(1),
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                gender: None,
                age: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

text: String

voice_id: i64

language: Languages

gender: Option<Gender>

age: Option<Option<i64>>

run_id: Option<Option<i64>>

client.text_to_speech.get_tts_result(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .get_tts_result(
            &"task_id".to_string(),
            &GetTtsResultQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.text_to_speech.get_tts_run_info(run_id: Option<i64>, output_type: Option<Option<String>>) -> Result<GetTtsRunInfoTtsResultRunIDGetResponse, ApiError>

📝 Description

Retrieves the result of a Text To Speech (TTS) run.

This endpoint validates the provided run_id and fetches the corresponding TTS-generated audio. The user must have valid access to the run. The function supports two output formats:

  • RAW_BYTES: Streams the audio file directly.
  • FILE_URL: Returns a pre-signed URL to download the audio file.

Args: run_id (int): Unique identifier for the TTS run. api_key_obj (dict): API key object used for authentication and storage preferences. traceparent (Optional[str]): Traceparent header for distributed tracing. output_type (OutputType, optional): Determines the output format. Defaults to RAW_BYTES.

Returns: StreamingResponse | GetTTSOut: - If output_type = RAW_BYTES: A streaming response containing the TTS-generated audio in FLAC format. - If output_type = FILE_URL: A URL pointing to the stored TTS-generated audio file.

Raises: HTTPException: - 400 BAD REQUEST if the run ID is invalid or does not belong to a TTS process. - 500 INTERNAL SERVER ERROR if fetching or streaming the audio fails.

Assumptions: - The user has valid access to the run_id. - The run_id corresponds to a valid TTS run. - There is only one dialogue associated with the given run_id.

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .get_tts_run_info(
            &Some(1),
            &GetTtsRunInfoQueryRequest { output_type: None },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

output_type: Option<String> — Output format for the Text To Speech result

client.text_to_speech.get_tts_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, GetTtsResultsTtsResultsPostResponseValue>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .get_tts_results(
            &GetTtsResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.text_to_speech.get_tts_result_discord(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .text_to_speech
        .get_tts_result_discord(
            &"task_id".to_string(),
            &GetTtsResultDiscordQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

Translation

client.translation.translation_stream(request: CreateTranslationStreamRequestPayload) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translation
        .translation_stream(
            &CreateTranslationStreamRequestPayload {
                source_language: Languages(1),
                target_language: Languages(1),
                text: "text".to_string(),
                formality: None,
                gender: None,
                team_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

source_language: Languages

target_language: Languages

text: String

formality: Option<Option<Formalities>>

gender: Option<Option<Gender>>

team_id: Option<Option<i64>>

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

client.translation.create_translation(request: CreateTranslationRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translation
        .create_translation(
            &CreateTranslationRequestPayload {
                texts: vec!["texts".to_string()],
                source_language: Languages(1),
                target_language: Languages(1),
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                age: None,
                formality: None,
                gender: None,
                chosen_dictionaries: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

texts: Vec<String>

age: Option<i64>

formality: Option<Formalities>

gender: Option<Gender>

source_language: Languages

target_language: Languages

chosen_dictionaries: Option<Option<Vec<i64>>>

run_id: Option<Option<i64>>

client.translation.get_translation_task_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translation
        .get_translation_task_status(
            &"task_id".to_string(),
            &GetTranslationTaskStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.translation.get_translation_result(run_id: Option<i64>) -> Result<TranslationResult, ApiError>

📝 Description

NOTE: This endpoint should be called only by the users to get values for their runs via API. Further we need to validate if the user has access to the run_id, otherwise we should not return the output urls.

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translation
        .get_translation_result(&Some(1), None)
        .await;
}

⚙️ Parameters

run_id: Option<i64>

client.translation.get_translation_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, TranslationResult>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translation
        .get_translation_results(
            &GetTranslationResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

Transcription

client.transcription.create_transcription(run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineCallResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .transcription
        .create_transcription(
            &CreateTranscriptionRequest {
                media_file: b"test file content".to_vec(),
                file: b"test file content".to_vec(),
                language: Languages(1),
                media_url: None,
                audio_url: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.transcription.get_transcription_task_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .transcription
        .get_transcription_task_status(
            &"task_id".to_string(),
            &GetTranscriptionTaskStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.transcription.get_transcription_result(run_id: Option<i64>, word_level_timestamps: Option<Option<Option<bool>>>) -> Result<TranscriptionResult, ApiError>

📝 Description

NOTE: This endpoint should be called only by the users to get values for their runs via API. Further we need to validate if the user has access to the run_id, otherwise we should not return the output urls.

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .transcription
        .get_transcription_result(
            &Some(1),
            &GetTranscriptionResultQueryRequest {
                word_level_timestamps: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<i64>

word_level_timestamps: Option<Option<bool>>

client.transcription.get_transcription_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, TranscriptionResult>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .transcription
        .get_transcription_results(
            &GetTranscriptionResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

TranslatedTts

client.translated_tts.create_translated_tts(request: CreateTranslatedTtsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<CreateTranslatedTtsOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translated_tts
        .create_translated_tts(
            &CreateTranslatedTtsRequestPayload {
                text: "text".to_string(),
                voice_id: 1,
                source_language: Languages(1),
                target_language: Languages(1),
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                age: None,
                formality: None,
                gender: None,
                chosen_dictionaries: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

text: String

voice_id: i64

age: Option<Option<i64>>

formality: Option<Option<Formalities>>

gender: Option<Option<Gender>>

source_language: Languages

target_language: Languages

chosen_dictionaries: Option<Option<Vec<i64>>>

run_id: Option<Option<i64>>

client.translated_tts.get_translated_tts_task_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<OrchestratorPipelineResult, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .translated_tts
        .get_translated_tts_task_status(
            &"task_id".to_string(),
            &GetTranslatedTtsTaskStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

Streaming

client.streaming.create_stream(request: CreateStreamRequestPayload) -> Result<CreateStreamOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .streaming
        .create_stream(
            &CreateStreamRequestPayload {
                name: None,
                description: None,
                initial_delay: None,
                timeout_in_mins: None,
                voices: vec![1],
                dictionaries: vec![1],
                config: ConfigStream {
                    pipeline: None,
                    mixing: None,
                },
                source_stream: SourceStream {
                    language: Languages(1),
                    url: "url".to_string(),
                    category: None,
                    passphrase: None,
                    streamid: None,
                    number_of_streams: None,
                    audio_stream: None,
                    background_audio_stream: None,
                    latency: None,
                    relay_input: None,
                },
                target_streams: vec![TargetStream {
                    languages: vec![Languages(1)],
                    url: "url".to_string(),
                    r#type: StreamType(1),
                    passphrase: None,
                    streamid: None,
                    pids: None,
                    transcode_video: None,
                    embed_subtitles: None,
                    audio_codec: None,
                    audio_bitrate: None,
                    audio_channel_layout: None,
                    latency: None,
                    constant_bitrate: None,
                    relay_output: None,
                }],
                start_time: None,
                end_time: None,
                timezone: None,
            },
            None,
        )
        .await;
}
client.streaming.get_stream_result(stream_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .streaming
        .get_stream_result(1, &GetStreamResultQueryRequest2 { run_id: None }, None)
        .await;
}

⚙️ Parameters

stream_id: i64

run_id: Option<Option<i64>>

client.streaming.destroy_stream(stream_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .streaming
        .destroy_stream(1, &DestroyStreamQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

stream_id: i64

run_id: Option<Option<i64>>

client.streaming.patch_stream_data(stream_id: i64, request: UpdateStreamDataRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .streaming
        .patch_stream_data(
            1,
            &UpdateStreamDataRequestPayload {
                run_id: None,
                start_time: None,
                end_time: None,
                payload: None,
                target_languages: None,
                timezone: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

stream_id: i64

start_time: Option<Option<String>>

end_time: Option<Option<String>>

payload: Option<Option<std::collections::HashMap<String, serde_json::Value>>>

target_languages: Option<Option<Vec<Languages>>>

timezone: Option<Option<String>>

run_id: Option<Option<i64>>

client.streaming.get_probe_stream(request: GetProbeStreamIn, run_id: Option<Option<Option<i64>>>) -> Result<GetProbeStreamOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .streaming
        .get_probe_stream(
            &GetProbeStreamRequest {
                body: GetProbeStreamIn {
                    url: "url".to_string(),
                    passphrase: None,
                    stream_id: None,
                },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

VoiceCloning

client.voice_cloning.list_voices(run_id: Option<Option<Option<i64>>>) -> Result<Vec<ListVoicesListVoicesGetResponseItem>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .voice_cloning
        .list_voices(&ListVoicesQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.voice_cloning.create_custom_voice(run_id: Option<Option<Option<i64>>>) -> Result<CreateCustomVoiceOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .voice_cloning
        .create_custom_voice(
            &CreateCustomVoiceRequest {
                file: b"test file content".to_vec(),
                voice_name: "voice_name".to_string(),
                gender: Gender(1),
                description: None,
                publish_voice_to_market_place: None,
                age: None,
                language: None,
                enhance_audio: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

Dictionaries

client.dictionaries.get_dictionaries(run_id: Option<Option<Option<i64>>>) -> Result<Vec<DictionaryWithTerms>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .get_dictionaries(&GetDictionariesQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.dictionaries.create_dictionary_from_file(run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .create_dictionary_from_file(
            &CreateDictionaryFromFileRequest {
                dictionary_file: b"test file content".to_vec(),
                dictionary_name: "dictionary_name".to_string(),
                dictionary_description: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

client.dictionaries.get_dictionary_info(dictionary_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<DictionaryWithTerms, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .get_dictionary_info(1, &GetDictionaryInfoQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

dictionary_id: i64

run_id: Option<Option<i64>>

client.dictionaries.delete_dictionary(dictionary_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .delete_dictionary(1, &DeleteDictionaryQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

dictionary_id: i64

run_id: Option<Option<i64>>

client.dictionaries.get_dictionary_details(dictionary_id: i64, limit: Option<Option<Option<i64>>>, search_term: Option<Option<Option<String>>>, run_id: Option<Option<Option<i64>>>) -> Result<DictionaryWithTerms, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .get_dictionary_details(
            1,
            &GetDictionaryDetailsQueryRequest {
                limit: None,
                search_term: None,
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

dictionary_id: i64

limit: Option<Option<i64>> — Limit how many terms are returned when fetching the dictionary details.

search_term: Option<Option<String>>

run_id: Option<Option<i64>>

client.dictionaries.add_term_to_dictionary(dictionary_id: i64, request: AddDictionaryTermPayload, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .add_term_to_dictionary(
            1,
            &AddDictionaryTermPayload {
                translations: vec![TermTranslationInput {
                    translation: "translation".to_string(),
                    language: Languages(1),
                }],
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

dictionary_id: i64

translations: Vec<TermTranslationInput>

run_id: Option<Option<i64>>

client.dictionaries.update_term_translation_in_dictionary_using_term_id(dictionary_id: i64, term_id: i64, request: UpdateTermTranslationsPayload, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .update_term_translation_in_dictionary_using_term_id(
            1,
            1,
            &UpdateTermTranslationsPayload {
                translations: vec![TermTranslationInput {
                    translation: "translation".to_string(),
                    language: Languages(1),
                }],
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

dictionary_id: i64

term_id: i64

translations: Vec<TermTranslationInput>

run_id: Option<Option<i64>>

client.dictionaries.delete_dictionary_term(dictionary_id: i64, term_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<serde_json::Value, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .dictionaries
        .delete_dictionary_term(
            1,
            1,
            &DeleteDictionaryTermQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

dictionary_id: i64

term_id: i64

run_id: Option<Option<i64>>

ProjectSetup

client.project_setup.create_project(request: CreateProjectSetupRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<CreateProjectSetupOut, ApiError>

📝 Description

Creates a new project setup with transcription capabilities.

This endpoint allows users to create a new project by providing media content (either as a file upload or URL), specifying source and target languages, and other project metadata. The function validates inputs, checks file size limitations, and initiates the project setup process.

Args: request_payload (CreateProjectSetupRequestPayload): Complete project configuration including media URL, source/target languages, project metadata, and processing preferences such as audio track selection and dictionary choices. api_key_obj_and_subscription: Dependency injection providing validated API key object and associated subscription details for authorization and usage limit enforcement. traceparent (str | None, optional): OpenTelemetry trace parent header for distributed tracing across microservices. Enables request correlation and performance monitoring throughout the processing pipeline.

Returns: Project setup response with project details and processing status.

Raises: HTTPException: - 400: If neither media_file nor media_url is provided - 400: If uploaded file has no filename - 413: If uploaded file exceeds size limit

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .project_setup
        .create_project(
            &CreateProjectSetupRequestPayload {
                media_url: "media_url".to_string(),
                source_language: Languages(1),
                target_languages: vec![Languages(1)],
                run_id: None,
                project_name: None,
                project_description: None,
                folder_id: None,
                selected_audio_tracks: None,
                add_output_as_an_audio_track: None,
                chosen_dictionaries: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

project_name: Option<Option<String>>

project_description: Option<Option<String>>

folder_id: Option<Option<i64>>

media_url: String

source_language: Languages

target_languages: Vec<Languages>

selected_audio_tracks: Option<Option<Vec<i64>>>

add_output_as_an_audio_track: Option<Option<bool>>

chosen_dictionaries: Option<Vec<i64>>

run_id: Option<Option<i64>>

client.project_setup.create_project_setup_task_status(task_id: String, run_id: Option<Option<Option<i64>>>) -> Result<Vec<GetCreateProjectSetupResponse>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .project_setup
        .create_project_setup_task_status(
            &"task_id".to_string(),
            &CreateProjectSetupTaskStatusQueryRequest { run_id: None },
            None,
        )
        .await;
}

⚙️ Parameters

task_id: String

run_id: Option<Option<i64>>

client.project_setup.get_project_setup_result(run_id: Option<i64>) -> Result<Option<GetCreateProjectSetupResponse>, ApiError>

📝 Description

Retrieves the final result of a completed project setup.

This endpoint provides access to the final results of a completed project setup. It verifies that the authenticated user has access to the requested run_id and validates that the run is of the correct type (DUB_PROJECT) before returning results.

Note: This endpoint should only be called by users to retrieve their run results via API. Access validation is performed to ensure users can only access their own runs.

Args: run_id: Positive integer ID of the project setup run. api_key_obj: API key authentication data from dependency. traceparent: OpenTelemetry trace header for distributed tracing.

Returns: GetCreateProjectSetupResponse: Project setup results including run details.

Raises: HTTPException: - 404: If the run_id is not found - 400: If the run type is not valid for this endpoint (must be DUB_PROJECT)

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .project_setup
        .get_project_setup_result(&Some(1), None)
        .await;
}

⚙️ Parameters

run_id: Option<i64>

client.project_setup.get_project_setup_runs_results(request: RunIDsRequestPayload, run_id: Option<Option<Option<i64>>>) -> Result<Vec<GetCreateProjectSetupResponse>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .project_setup
        .get_project_setup_runs_results(
            &GetProjectSetupRunsResultsRequest {
                body: RunIDsRequestPayload { run_ids: vec![1] },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>

DeprecatedStreaming

client.deprecated_streaming.create_stream(request: CreateStreamRequestPayload) -> Result<CreateStreamOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .deprecated_streaming
        .create_stream(
            &CreateStreamRequestPayload {
                name: None,
                description: None,
                initial_delay: None,
                timeout_in_mins: None,
                voices: vec![1],
                dictionaries: vec![1],
                config: ConfigStream {
                    pipeline: None,
                    mixing: None,
                },
                source_stream: SourceStream {
                    language: Languages(1),
                    url: "url".to_string(),
                    category: None,
                    passphrase: None,
                    streamid: None,
                    number_of_streams: None,
                    audio_stream: None,
                    background_audio_stream: None,
                    latency: None,
                    relay_input: None,
                },
                target_streams: vec![TargetStream {
                    languages: vec![Languages(1)],
                    url: "url".to_string(),
                    r#type: StreamType(1),
                    passphrase: None,
                    streamid: None,
                    pids: None,
                    transcode_video: None,
                    embed_subtitles: None,
                    audio_codec: None,
                    audio_bitrate: None,
                    audio_channel_layout: None,
                    latency: None,
                    constant_bitrate: None,
                    relay_output: None,
                }],
                start_time: None,
                end_time: None,
                timezone: None,
            },
            None,
        )
        .await;
}
client.deprecated_streaming.get_stream_result(stream_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .deprecated_streaming
        .get_stream_result(1, &GetStreamResultQueryRequest2 { run_id: None }, None)
        .await;
}

⚙️ Parameters

stream_id: i64

run_id: Option<Option<i64>>

client.deprecated_streaming.stop_stream(stream_id: i64, run_id: Option<Option<Option<i64>>>) -> Result<std::collections::HashMap<String, serde_json::Value>, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .deprecated_streaming
        .stop_stream(1, &StopStreamQueryRequest { run_id: None }, None)
        .await;
}

⚙️ Parameters

stream_id: i64

run_id: Option<Option<i64>>

client.deprecated_streaming.get_probe_stream(request: GetProbeStreamIn, run_id: Option<Option<Option<i64>>>) -> Result<GetProbeStreamOut, ApiError>

🔌 Usage

use camb_api::prelude::*;

#[tokio::main]
async fn main() {
    let config = ClientConfig {
        api_key: Some("<value>".to_string()),
        ..Default::default()
    };
    let client = ApiClient::new(config).expect("Failed to build client");
    client
        .deprecated_streaming
        .get_probe_stream(
            &GetProbeStreamRequest {
                body: GetProbeStreamIn {
                    url: "url".to_string(),
                    passphrase: None,
                    stream_id: None,
                },
                run_id: None,
            },
            None,
        )
        .await;
}

⚙️ Parameters

run_id: Option<Option<i64>>