Rust API Reference

Rust API Reference v1.9.0-rc.1¶

Functions¶

create_client()¶

Create a new LLM client with simple scalar configuration.

This is the primary binding entry-point. All parameters except api_key are optional — omitting them uses the same defaults as ClientConfigBuilder.

Errors:

Returns LiterLlmError if the underlying HTTP client cannot be constructed, or if the resolved provider configuration is invalid.

Signature:

pub fn create_client(api_key: &str, base_url: Option<String>, timeout_secs: Option<u64>, max_retries: Option<u32>, model_hint: Option<String>) -> Result<DefaultClient, Error>

Example:

let result = create_client("value", "value", 42, 42, "value")?;

Parameters:

Returns: DefaultClient

Errors: Returns Err(Error).

create_client_from_json()¶

Create a new LLM client from a JSON string.

The JSON object accepts the same fields as liter-llm.toml (snake_case).

Errors:

Returns LiterLlmError::BadRequest if json is not valid JSON or contains unknown fields.

Signature:

pub fn create_client_from_json(json: &str) -> Result<DefaultClient, Error>

Example:

let result = create_client_from_json("value")?;

Parameters:

Returns: DefaultClient

Errors: Returns Err(Error).

encode_data_url()¶

Encode bytes as a base64 data URL: data:<mime>;base64,<b64>.

mime defaults to IMAGE_PNG when None.

Signature:

pub fn encode_data_url(bytes: &[u8], mime: Option<String>) -> String

Example:

use liter_llm::image::{encode_data_url, IMAGE_PNG, IMAGE_JPEG};

let url = encode_data_url(b"\x89PNG", Some(IMAGE_PNG));
assert!(url.starts_with("data:image/png;base64,"));

let url_default = encode_data_url(b"\x89PNG", None);
assert!(url_default.starts_with("data:image/png;base64,"));

let jpeg_url = encode_data_url(b"\xff\xd8\xff", Some(IMAGE_JPEG));
assert!(jpeg_url.starts_with("data:image/jpeg;base64,"));
```rust

**Parameters:**

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `bytes` | `Vec<u8>` | Yes | The bytes |
| `mime` | `Option<String>` | No | The mime |

**Returns:** `String`

---

#### decode_data_url()

Decode a base64 data URL into `DecodedDataUrl`.

Returns `None` for:

- Non-data URLs (strings that do not start with `"data:"`).
- Malformed prefixes (missing `";base64,"` marker).
- Invalid base64 payloads.

The returned MIME string is extracted verbatim from the URL prefix —
it is not validated or normalised.

**Signature:**

```rust
pub fn decode_data_url(url: &str) -> Option<DecodedDataUrl>

Example:

use liter_llm::image::{encode_data_url, decode_data_url, IMAGE_PNG};

let url = encode_data_url(b"hello", Some(IMAGE_PNG));
let decoded = decode_data_url(&url).expect("valid data URL");
assert_eq!(decoded.mime, IMAGE_PNG);
assert_eq!(decoded.data, b"hello");

// Non-data URLs return None.
assert!(decode_data_url("<https://example.com/img.png">).is_none());

// Missing ;base64, marker returns None.
assert!(decode_data_url("data:image/png,plaintext").is_none());
```rust

**Parameters:**

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `url` | `String` | Yes | The URL to fetch |

**Returns:** `Option<DecodedDataUrl>`

---

#### register_custom_provider()

Register a custom provider in the global runtime registry.

The provider will be checked **before** all built-in providers during model
detection. If a provider with the same `name` already exists it is replaced.

**Errors:**

Returns an error if the config is invalid (empty name, empty base_url, or
no model prefixes).

**Signature:**

```rust
pub fn register_custom_provider(config: CustomProviderConfig) -> Result<(), Error>

Example:

register_custom_provider(CustomProviderConfig::default())?;

Parameters:

Returns: No return value.

Errors: Returns Err(Error).

unregister_custom_provider()¶

Remove a previously registered custom provider by name.

Returns true if a provider with the given name was found and removed, false if no such provider existed.

Errors:

Returns an error if the custom-provider registry cannot be updated.

Signature:

pub fn unregister_custom_provider(name: &str) -> Result<bool, Error>

Example:

let result = unregister_custom_provider("value")?;

Parameters:

Returns: bool

Errors: Returns Err(Error).

capabilities()¶

Return the capability flags for a named provider.

Performs an O(n) linear scan over the embedded registry (143 entries). Returns an owned value so bindings can pass capability data without borrowing registry internals.

For unknown provider_name values the function returns an all-false sentinel so callers never need to handle Option.

Signature:

pub fn capabilities(provider_name: &str) -> ProviderCapabilities

Example:

let result = capabilities("value");

Parameters:

Returns: ProviderCapabilities

all_providers()¶

Return all provider configs from the registry.

Useful for tooling, documentation generation, or runtime enumeration. Returns the public ProviderConfig slice (without capability flags). To query capability flags for a specific provider use capabilities.

Signature:

pub fn all_providers() -> Result<Vec<ProviderConfig>, Error>

Example:

let result = all_providers()?;

Returns: Vec<ProviderConfig>

Errors: Returns Err(Error).

complex_provider_names()¶

Return the set of complex provider names.

Complex providers require custom auth/routing logic beyond simple bearer tokens (e.g. AWS Bedrock SigV4, Vertex AI OAuth2).

The returned reference points into the static registry — no allocation.

Signature:

pub fn complex_provider_names() -> Result<Vec<String>, Error>

Example:

let result = complex_provider_names()?;

Returns: Vec<String>

Errors: Returns Err(Error).

completion_cost()¶

Calculate the estimated cost of a completion given a model name and token counts.

Returns None if the model is not present in the embedded pricing registry. Returns Some(cost_usd) otherwise, where the value is in US dollars.

When an exact model name match is not found, progressively shorter prefixes are tried by stripping from the last - or . separator. For example, gpt-4-0613 will match gpt-4 if no gpt-4-0613 entry exists.

Signature:

pub fn completion_cost(model: &str, prompt_tokens: u64, completion_tokens: u64) -> Option<f64>

Example:

use liter_llm::cost;

let usd = cost::completion_cost("gpt-4o", 1_000, 500).expect("gpt-4o is a known model");
// 1000 * 0.0000025 + 500 * 0.00001 = 0.0025 + 0.005 = 0.0075
assert!((usd - 0.0075).abs() < 1e-9);
```rust

**Parameters:**

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `model` | `String` | Yes | The model |
| `prompt_tokens` | `u64` | Yes | The prompt tokens |
| `completion_tokens` | `u64` | Yes | The completion tokens |

**Returns:** `Option<f64>`

---

#### completion_cost_with_cache()

Calculate the estimated cost of a completion, accounting for cached
(cache-hit) prompt tokens billed at the provider's discounted rate.

`cached_tokens` is the count of prompt tokens served from the provider's
prompt cache. It must be `<= prompt_tokens` (cached tokens are a subset of
the prompt). The non-cached portion is billed at `input_cost_per_token`
and the cached portion at `cache_read_input_token_cost` when the model
has cache pricing; otherwise the entire prompt is billed at the regular
input rate.

Returns `None` if the model is not present in the embedded pricing
registry, mirroring `completion_cost`.

**Signature:**

```rust
pub fn completion_cost_with_cache(model: &str, prompt_tokens: u64, cached_tokens: u64, completion_tokens: u64) -> Option<f64>

Example:

let result = completion_cost_with_cache("value", 42, 42, 42);

Parameters:

Returns: Option<f64>

clear()¶

Remove all guardrails from the global registry.

Primarily useful in tests to reset state between test cases.

Panics:

Panics if the global registry lock is poisoned.

Signature:

pub fn clear()

Example:

clear();

Returns: No return value.

count_tokens()¶

Count tokens in a text string using the tokenizer for the given model.

The tokenizer is resolved from the model name prefix (e.g. "gpt-4o" maps to the Xenova/gpt-4o HuggingFace tokenizer). Tokenizers are cached after first load.

Errors:

Returns LiterLlmError::BadRequest if the tokenizer cannot be loaded (e.g. network failure on first use) or if tokenization itself fails.

Signature:

pub fn count_tokens(model: &str, text: &str) -> Result<usize, Error>

Example:

let result = count_tokens("value", "value")?;

Parameters:

Returns: usize

Errors: Returns Err(Error).

count_request_tokens()¶

Count tokens for a full ChatCompletionRequest.

Sums tokens across all message text contents plus a per-message overhead of ~4 tokens (for role, separators, and formatting metadata). Tool definitions and multimodal content parts (images, audio, documents) are not counted — only textual content contributes to the token total.

Errors:

Returns LiterLlmError::BadRequest if the tokenizer cannot be loaded or if tokenization fails for any message.

Signature:

pub fn count_request_tokens(model: &str, req: ChatCompletionRequest) -> Result<usize, Error>

Example:

let result = count_request_tokens("value", ChatCompletionRequest::default())?;

Parameters:

Returns: usize

Errors: Returns Err(Error).

check_bound()¶

Assert that current_len + incoming does not exceed limit.

Call this before appending incoming bytes to any buffer that must stay below limit. Returns Err(LiterLlmError::Streaming) on overflow and emits a tracing::warn! with context.

Signature:

pub fn check_bound(context: &str, current_len: usize, incoming: usize, limit: usize) -> Result<(), Error>

Example:

check_bound("SSE buffer", buffer.len(), chunk.len(), SSE_BUFFER_MAX_BYTES)?;
buffer.push_str(chunk_str);
```rust

**Parameters:**

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `context` | `String` | Yes | The context |
| `current_len` | `usize` | Yes | The current len |
| `incoming` | `usize` | Yes | The incoming |
| `limit` | `usize` | Yes | The limit |

**Returns:** No return value.

**Errors:** Returns `Err(Error)`.

---

#### ensure_crypto_provider()

Install the `ring` crypto provider as the rustls process default, idempotently.

rustls 0.23+ removed the implicit default provider. This function installs
`ring` once per process. Subsequent calls are no-ops. Calling it after
another rustls crypto provider has already been installed is safe: the
`Err` from `install_default()` is silently ignored.

Called automatically by every internal `reqwest::Client` constructor
(auth providers, default HTTP client). Bindings and downstream consumers
reach those constructors transitively, so no manual init is required.

WASM builds are exempt — the WASM target uses the browser/Node.js fetch
API instead of rustls, so no crypto provider is needed.

Windows builds use native-tls (SChannel) via reqwest, so rustls is not
present and no crypto provider installation is needed.

**Signature:**

```rust
pub fn ensure_crypto_provider()

Example:

ensure_crypto_provider();

Returns: No return value.

ensure_crypto_provider()¶

No-op on Windows: reqwest uses native-tls (SChannel), so no rustls provider installation is needed. All callers use the same call site regardless of platform.

Signature:

pub fn ensure_crypto_provider()

Example:

ensure_crypto_provider();

Returns: No return value.

Types¶

AssistantMessage¶

Assistant's response to a user message.

Methods¶

text()¶

Return the assistant's textual response, concatenating all Text parts if the content is structured.

Returns None for Refusal-only or OutputImage-only responses.

Signature:

pub fn text(&self) -> Option<String>

Example:

let result = instance.text();

Returns: Option<String>

refusal_text()¶

Return the refusal message, if the model declined to respond.

Checks both the top-level refusal field and any Refusal parts inside a structured content.

Signature:

pub fn refusal_text(&self) -> Option<String>

Example:

let result = instance.refusal_text();

Returns: Option<String>

output_images()¶

Return all AssistantPart::OutputImage parts in the response.

Signature:

pub fn output_images(&self) -> Vec<ImageUrl>

Example:

let result = instance.output_images();

Returns: Vec<ImageUrl>

output_audio()¶

Return all AssistantPart::OutputAudio parts in the response.

Signature:

pub fn output_audio(&self) -> Vec<AudioContent>

Example:

let result = instance.output_audio();

Returns: Vec<AudioContent>

AudioContent¶

Audio content part for speech-capable models.

AuthConfig¶

Auth configuration block.

BatchListQuery¶

Query parameters for listing batches.

BatchListResponse¶

Response from listing batches.

BatchObject¶

A batch job object.

BatchRequestCounts¶

Request processing counts for a batch.

BudgetConfig¶

Configuration for budget enforcement.

Methods¶

default()¶

Signature:

pub fn default() -> BudgetConfig

Example:

let result = BudgetConfig::default();

Returns: BudgetConfig

CacheConfig¶

Configuration for the response cache.

Methods¶

default()¶

Signature:

pub fn default() -> CacheConfig

Example:

let result = CacheConfig::default();

Returns: CacheConfig

ChatCompletionChunk¶

A streamed chunk of a chat completion response.

ChatCompletionRequest¶

Chat completion request (compatible with OpenAI and similar APIs).

ChatCompletionResponse¶

Chat completion response from the API.

ChatCompletionTool¶

A tool the model can invoke (currently, all tools are functions).

Choice¶

A single completion choice.

ChunkMiddleware¶

A per-chunk transformation in the StreamPipeline.

Each middleware receives a typed chunk and returns Ok(Some(chunk)) to pass it through (optionally modified), Ok(None) to drop the chunk, or Err(e) to propagate a stream error.

The trait is object-safe so multiple middleware implementations can be chained inside StreamPipeline.

Methods¶

process()¶

Process a single chunk.

• Ok(Some(chunk)) — emit (possibly transformed) chunk.
• Ok(None) — drop this chunk silently.
• Err(e) — propagate as a stream error.

Signature:

pub fn process(&self, chunk: ChatCompletionChunk) -> Result<Option<ChatCompletionChunk>, Error>

Example:

let result = instance.process(ChatCompletionChunk::default())?;

Parameters:

Returns: Option<ChatCompletionChunk>

Errors: Returns Err(Error).

CreateBatchRequest¶

Request to create a batch job.

CreateFileRequest¶

Request to upload a file.

CreateImageRequest¶

Request to create images from a text prompt.

CreateResponseRequest¶

Request to create a structured response.

CreateSpeechRequest¶

Request to generate speech audio from text.

CreateTranscriptionRequest¶

Request to transcribe audio into text.

CustomProviderConfig¶

Configuration for registering a custom LLM provider at runtime.

DecodedDataUrl¶

Result of decoding a data: URL — MIME type and the decoded byte payload.

Named struct (rather than a tuple) so polyglot bindings can extract decode_data_url with a typed return rather than a sanitized scalar.

DefaultClient¶

Default client implementation backed by reqwest.

Sends requests to 143 LLM providers with automatic provider detection and per-request routing. The provider is resolved at construction time from model_hint (or defaults to OpenAI), but individual requests can override the provider via model name prefix (e.g. "anthropic/claude-3-5-sonnet" routes to Anthropic regardless of construction-time setting).

When the model prefix does not match any known provider, the construction-time provider is used as the fallback. This enables seamless migration between providers by changing only the model name.

The provider is stored behind an Arc so it can be shared cheaply into async closures and streaming tasks. Pre-computed auth headers and extra headers are cached at construction to avoid redundant encoding on every request.

Methods¶

chat()¶

Signature:

pub async fn chat(&self, req: ChatCompletionRequest) -> Result<ChatCompletionResponse, Error>

Example:

let result = instance.chat(ChatCompletionRequest::default()).await?;

Parameters:

Returns: ChatCompletionResponse

Errors: Returns Err(Error).

chat_stream()¶

Signature:

fn chat_stream(&self, req: ChatCompletionRequest) -> BoxFuture<'_, Result<BoxStream<'static, Result<ChatCompletionChunk>>>>

Example:

let mut stream = instance.chat_stream(ChatCompletionRequest::default()).await?;
while let Some(chunk) = stream.next().await {
    let chunk = chunk?;
    println!("{chunk:?}");
}

Parameters:

Returns: BoxFuture<'_, Result<BoxStream<'static, Result<ChatCompletionChunk>>>>

Errors: Returns Err(Error).

embed()¶

Signature:

pub async fn embed(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, Error>

Example:

let result = instance.embed(EmbeddingRequest::default()).await?;

Parameters:

Returns: EmbeddingResponse

Errors: Returns Err(Error).

list_models()¶

Signature:

pub async fn list_models(&self) -> Result<ModelsListResponse, Error>

Example:

let result = instance.list_models().await?;

Returns: ModelsListResponse

Errors: Returns Err(Error).

image_generate()¶

Signature:

pub async fn image_generate(&self, req: CreateImageRequest) -> Result<ImagesResponse, Error>

Example:

let result = instance.image_generate(CreateImageRequest::default()).await?;

Parameters:

Returns: ImagesResponse

Errors: Returns Err(Error).

speech()¶

Signature:

pub async fn speech(&self, req: CreateSpeechRequest) -> Result<Vec<u8>, Error>

Example:

let result = instance.speech(CreateSpeechRequest::default()).await?;

Parameters:

Returns: Vec<u8>

Errors: Returns Err(Error).

transcribe()¶

Signature:

pub async fn transcribe(&self, req: CreateTranscriptionRequest) -> Result<TranscriptionResponse, Error>

Example:

let result = instance.transcribe(CreateTranscriptionRequest::default()).await?;

Parameters:

Returns: TranscriptionResponse

Errors: Returns Err(Error).

moderate()¶

Signature:

pub async fn moderate(&self, req: ModerationRequest) -> Result<ModerationResponse, Error>

Example:

let result = instance.moderate(ModerationRequest::default()).await?;

Parameters:

Returns: ModerationResponse

Errors: Returns Err(Error).

rerank()¶

Signature:

pub async fn rerank(&self, req: RerankRequest) -> Result<RerankResponse, Error>

Example:

let result = instance.rerank(RerankRequest::default()).await?;

Parameters:

Returns: RerankResponse

Errors: Returns Err(Error).

search()¶

Signature:

pub async fn search(&self, req: SearchRequest) -> Result<SearchResponse, Error>

Example:

let result = instance.search(SearchRequest::default()).await?;

Parameters:

Returns: SearchResponse

Errors: Returns Err(Error).

ocr()¶

Signature:

pub async fn ocr(&self, req: OcrRequest) -> Result<OcrResponse, Error>

Example:

let result = instance.ocr(OcrRequest::default()).await?;

Parameters:

Returns: OcrResponse

Errors: Returns Err(Error).

create_file()¶

Signature:

pub async fn create_file(&self, req: CreateFileRequest) -> Result<FileObject, Error>

Example:

let result = instance.create_file(CreateFileRequest::default()).await?;

Parameters:

Returns: FileObject

Errors: Returns Err(Error).

retrieve_file()¶

Signature:

pub async fn retrieve_file(&self, file_id: &str) -> Result<FileObject, Error>

Example:

let result = instance.retrieve_file("value").await?;

Parameters:

Returns: FileObject

Errors: Returns Err(Error).

delete_file()¶

Signature:

pub async fn delete_file(&self, file_id: &str) -> Result<DeleteResponse, Error>

Example:

let result = instance.delete_file("value").await?;

Parameters:

Returns: DeleteResponse

Errors: Returns Err(Error).

list_files()¶

Signature:

pub async fn list_files(&self, query: Option<FileListQuery>) -> Result<FileListResponse, Error>

Example:

let result = instance.list_files(FileListQuery::default()).await?;

Parameters:

Returns: FileListResponse

Errors: Returns Err(Error).

file_content()¶

Signature:

pub async fn file_content(&self, file_id: &str) -> Result<Vec<u8>, Error>

Example:

let result = instance.file_content("value").await?;

Parameters:

Returns: Vec<u8>

Errors: Returns Err(Error).

create_batch()¶

Signature:

pub async fn create_batch(&self, req: CreateBatchRequest) -> Result<BatchObject, Error>

Example:

let result = instance.create_batch(CreateBatchRequest::default()).await?;

Parameters:

Returns: BatchObject

Errors: Returns Err(Error).

retrieve_batch()¶

Signature:

pub async fn retrieve_batch(&self, batch_id: &str) -> Result<BatchObject, Error>

Example:

let result = instance.retrieve_batch("value").await?;

Parameters:

Returns: BatchObject

Errors: Returns Err(Error).

list_batches()¶

Signature:

pub async fn list_batches(&self, query: Option<BatchListQuery>) -> Result<BatchListResponse, Error>

Example:

let result = instance.list_batches(BatchListQuery::default()).await?;

Parameters:

Returns: BatchListResponse

Errors: Returns Err(Error).

cancel_batch()¶

Signature:

pub async fn cancel_batch(&self, batch_id: &str) -> Result<BatchObject, Error>

Example:

let result = instance.cancel_batch("value").await?;

Parameters:

Returns: BatchObject

Errors: Returns Err(Error).

fetch_batch_for_polling()¶

Signature:

pub async fn fetch_batch_for_polling(&self, batch_id: &str) -> Result<BatchObject, Error>

Example:

let result = instance.fetch_batch_for_polling("value").await?;

Parameters:

Returns: BatchObject

Errors: Returns Err(Error).

wait_for_batch()¶

Poll a batch until it reaches a terminal status (Completed, Failed, Expired, Cancelled).

Uses exponential backoff with configurable initial interval, maximum interval, and backoff multiplier. Optionally supports a timeout that aborts polling if exceeded.

Errors:

Returns BatchWaitError::Failed if the batch reaches a failure terminal status. Returns BatchWaitError::Timeout if the configured timeout is exceeded. Returns BatchWaitError::Client for underlying client errors.

Signature:

pub async fn wait_for_batch(&self, batch_id: &str, config: WaitForBatchConfig) -> Result<BatchObject, BatchWaitError>

Example:

# use liter_llm::client::{DefaultClient, ClientConfig, WaitForBatchConfig};
# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let client = DefaultClient::new(ClientConfig::new("api-key"), None)?;
let batch = client.wait_for_batch("b-123", WaitForBatchConfig::default()).await?;
println!("Batch completed: {:?}", batch.status);
# Ok(())
# }
```rust

**Parameters:**

| Name | Type | Required | Description |
|------|------|----------|-------------|
| `batch_id` | `String` | Yes | The batch id |
| `config` | `WaitForBatchConfig` | Yes | The configuration options |

**Returns:** `BatchObject`

**Errors:** Returns `Err(BatchWaitError)`.

###### create_response()

**Signature:**

```rust
pub async fn create_response(&self, req: CreateResponseRequest) -> Result<ResponseObject, Error>

Example:

let result = instance.create_response(CreateResponseRequest::default()).await?;

Parameters:

Returns: ResponseObject

Errors: Returns Err(Error).

retrieve_response()¶

Signature:

pub async fn retrieve_response(&self, response_id: &str) -> Result<ResponseObject, Error>

Example:

let result = instance.retrieve_response("value").await?;

Parameters:

Returns: ResponseObject

Errors: Returns Err(Error).

cancel_response()¶

Signature:

pub async fn cancel_response(&self, response_id: &str) -> Result<ResponseObject, Error>

Example:

let result = instance.cancel_response("value").await?;

Parameters:

Returns: ResponseObject

Errors: Returns Err(Error).

DeleteResponse¶

Response from a delete operation.

DeveloperMessage¶

Developer message (system-like message for Claude models).

DocumentContent¶

PDF/document content part for vision-capable models.

EmbeddingObject¶

A single embedding vector.

EmbeddingRequest¶

Embedding request.

EmbeddingResponse¶

Embedding response.

FileListQuery¶

Query parameters for listing files.

FileListResponse¶

Response from listing files.

FileObject¶

An uploaded file object.

FunctionCall¶

Function call details.

FunctionDefinition¶

Function definition exposed to the model.

FunctionMessage¶

Deprecated legacy function-role message body.

HealthChecker¶

Abstraction over a health probe strategy.

Implementors issue a lightweight probe against upstream (typically a provider base URL or named identifier) and report HealthStatus.

Methods¶

check()¶

Probe upstream and return its current HealthStatus.

The parameter is taken by value (String) so that implementations can move it into the returned future without a clone, making the 'static + Send bound on the future trivially satisfiable.

Signature:

pub async fn check(&self, upstream: &str) -> HealthStatus

Example:

let result = instance.check("value").await;

Parameters:

Returns: HealthStatus

Image¶

A single generated image, returned as either a URL or base64 data.

ImageUrl¶

An image URL reference with optional detail level for processing.

ImagesResponse¶

Response containing generated images.

IntentPrototype¶

An intent prototype: (intent_name, prototype_embedding, target_model_id).

JsonSchemaFormat¶

JSON Schema specification for constrained output.

ModelObject¶

A model available from the API.

ModelsListResponse¶

Response listing available models.

ModerationCategories¶

Boolean flags for each moderation category.

ModerationCategoryScores¶

Confidence scores for each moderation category.

ModerationRequest¶

Request to classify content for policy violations.

ModerationResponse¶

Response from the moderation endpoint.

ModerationResult¶

A single moderation classification result.

OcrImage¶

An image extracted from an OCR page.

OcrPage¶

A single page of OCR output.

OcrRequest¶

An OCR request.