openai-types 0.1.3

// AUTO-GENERATED by py2rust — do not edit.
// Re-generate: python3 scripts/py2rust.py sync <python_dir> <rust_dir>
// Domain: realtime
#![allow(unused_imports)]

use serde::{Deserialize, Serialize};
use super::*;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioTranscription {
    /// The language of the input audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub language: Option<String>,
    /// The model to use for transcription.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// An optional text to guide the model's style or continue a previous audio
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CallAcceptParams {
    /// The type of session to create. Always `realtime` for the Realtime API.
    #[serde(rename = "type")]
    pub type_: String,
    /// Configuration for input and output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<serde_json::Value>,
    /// Additional fields to include in server outputs.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<String>>,
    /// The default system instructions (i.e.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// Maximum number of output tokens for a single assistant response, inclusive of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<String>,
    /// The Realtime model used for this session.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// The set of modalities the model can respond with.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_modalities: Option<Vec<serde_json::Value>>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<serde_json::Value>,
    /// How the model chooses tools.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<serde_json::Value>,
    /// Tools available to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<serde_json::Value>,
    /// Realtime API can write session traces to the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tracing: Option<serde_json::Value>,
    /// When the number of tokens in a conversation exceeds the model's input token
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CallCreateParams {
    /// WebRTC Session Description Protocol (SDP) offer generated by the caller.
    pub sdp: String,
    /// Realtime session object configuration.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub session: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CallReferParams {
    /// URI that should appear in the SIP Refer-To header.
    pub target_uri: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CallRejectParams {
    /// SIP response code to send back to the caller.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status_code: Option<i64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ClientSecretCreateParams {
    /// Configuration for the client secret expiration.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub expires_after: Option<ExpiresAfter>,
    /// Session configuration to use for the client secret.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub session: Option<Session>,
}

/// Configuration for the client secret expiration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ExpiresAfter {
    /// The anchor point for the client secret expiration, meaning that `seconds` will
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub anchor: Option<String>,
    /// The number of seconds from the anchor point to the expiration.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub seconds: Option<i64>,
}

pub type Session = serde_json::Value;

/// Response from creating a session and client secret for the Realtime API.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ClientSecretCreateResponse {
    /// Expiration timestamp for the client secret, in seconds since epoch.
    pub expires_at: i64,
    /// The session configuration for either a realtime or transcription session.
    pub session: Session,
    /// The generated client secret value.
    pub value: String,
}

/// The conversation resource.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Conversation {
    /// The unique ID of the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The object type, must be `realtime.conversation`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
}

/// Returned when a conversation is created. Emitted right after session creation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationCreatedEvent {
    /// The conversation resource.
    pub conversation: Conversation,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The event type, must be `conversation.created`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type ConversationItem = serde_json::Value;

/// Sent by the server when an Item is added to the default Conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemAdded {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The event type, must be `conversation.item.added`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the item that precedes this one, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_item_id: Option<String>,
}

/// Add a new Item to the Conversation's context, including messages, function
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemCreateEvent {
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The event type, must be `conversation.item.create`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
    /// The ID of the preceding item after which the new item will be inserted.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_item_id: Option<String>,
}

/// Returned when a conversation item is created.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemCreatedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The event type, must be `conversation.item.created`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the preceding item in the Conversation context, allows the client to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_item_id: Option<String>,
}

/// Send this event when you want to remove any item from the conversation
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemDeleteEvent {
    /// The ID of the item to delete.
    pub item_id: String,
    /// The event type, must be `conversation.item.delete`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Returned when an item in the conversation is deleted by the client with a
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemDeletedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item that was deleted.
    pub item_id: String,
    /// The event type, must be `conversation.item.deleted`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when a conversation item is finalized.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemDone {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The event type, must be `conversation.item.done`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the item that precedes this one, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_item_id: Option<String>,
}

/// Details about the input tokens billed for this request.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UsageTranscriptTextUsageTokensInputTokenDetails {
    /// Number of audio tokens billed for this request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio_tokens: Option<i64>,
    /// Number of text tokens billed for this request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text_tokens: Option<i64>,
}

/// Usage statistics for models billed by token usage.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UsageTranscriptTextUsageTokens {
    /// Number of input tokens billed for this request.
    pub input_tokens: i64,
    /// Number of output tokens generated.
    pub output_tokens: i64,
    /// Total number of tokens used (input + output).
    pub total_tokens: i64,
    /// The type of the usage object. Always `tokens` for this variant.
    #[serde(rename = "type")]
    pub type_: String,
    /// Details about the input tokens billed for this request.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_token_details: Option<UsageTranscriptTextUsageTokensInputTokenDetails>,
}

/// Usage statistics for models billed by audio input duration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct UsageTranscriptTextUsageDuration {
    /// Duration of the input audio in seconds.
    pub seconds: f64,
    /// The type of the usage object. Always `duration` for this variant.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Usage = serde_json::Value;

/// This event is the output of audio transcription for user audio written to the
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemInputAudioTranscriptionCompletedEvent {
    /// The index of the content part containing the audio.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item containing the audio that is being transcribed.
    pub item_id: String,
    /// The transcribed text.
    pub transcript: String,
    /// The event type, must be `conversation.item.input_audio_transcription.completed`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Usage statistics for the transcription, this is billed according to the ASR
    pub usage: Usage,
    /// The log probabilities of the transcription.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub logprobs: Option<Vec<LogProbProperties>>,
}

/// Returned when the text value of an input audio transcription content part is updated with incremental transcription results.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemInputAudioTranscriptionDeltaEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item containing the audio that is being transcribed.
    pub item_id: String,
    /// The event type, must be `conversation.item.input_audio_transcription.delta`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The index of the content part in the item's content array.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub content_index: Option<i64>,
    /// The text delta.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub delta: Option<String>,
    /// The log probabilities of the transcription.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub logprobs: Option<Vec<LogProbProperties>>,
}

/// Details of the transcription error.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemError {
    /// Error code, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// A human-readable error message.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub message: Option<String>,
    /// Parameter related to the error, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub param: Option<String>,
    /// The type of error.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// Returned when input audio transcription is configured, and a transcription
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemInputAudioTranscriptionFailedEvent {
    /// The index of the content part containing the audio.
    pub content_index: i64,
    /// Details of the transcription error.
    pub error: serde_json::Value,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the user message item.
    pub item_id: String,
    /// The event type, must be `conversation.item.input_audio_transcription.failed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when an input audio transcription segment is identified for an item.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemInputAudioTranscriptionSegment {
    /// The segment identifier.
    pub id: String,
    /// The index of the input audio content part within the item.
    pub content_index: i64,
    /// End time of the segment in seconds.
    pub end: f64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item containing the input audio content.
    pub item_id: String,
    /// The detected speaker label for this segment.
    pub speaker: String,
    /// Start time of the segment in seconds.
    pub start: f64,
    /// The text for this segment.
    pub text: String,
    /// The event type, must be `conversation.item.input_audio_transcription.segment`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemRetrieveEvent {
    /// The ID of the item to retrieve.
    pub item_id: String,
    /// The event type, must be `conversation.item.retrieve`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Send this event to truncate a previous assistant message’s audio.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemTruncateEvent {
    /// Inclusive duration up to which audio is truncated, in milliseconds.
    pub audio_end_ms: i64,
    /// The index of the content part to truncate. Set this to `0`.
    pub content_index: i64,
    /// The ID of the assistant message item to truncate.
    pub item_id: String,
    /// The event type, must be `conversation.item.truncate`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Returned when an earlier assistant audio message item is truncated by the
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemTruncatedEvent {
    /// The duration up to which the audio was truncated, in milliseconds.
    pub audio_end_ms: i64,
    /// The index of the content part that was truncated.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the assistant message item that was truncated.
    pub item_id: String,
    /// The event type, must be `conversation.item.truncated`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Send this event to append audio bytes to the input audio buffer.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferAppendEvent {
    /// Base64-encoded audio bytes.
    pub audio: String,
    /// The event type, must be `input_audio_buffer.append`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Send this event to clear the audio bytes in the buffer.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferClearEvent {
    /// The event type, must be `input_audio_buffer.clear`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Returned when the input audio buffer is cleared by the client with a
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferClearedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The event type, must be `input_audio_buffer.cleared`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Send this event to commit the user input audio buffer, which will create a  new user message item in the conversation. This event will produce an error  if the input audio buffer is empty. When in Server VAD mode, the client does  not need to send this event, the server will commit the audio buffer  automatically.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferCommitEvent {
    /// The event type, must be `input_audio_buffer.commit`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Returned when an input audio buffer is committed, either by the client or
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferCommittedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the user message item that will be created.
    pub item_id: String,
    /// The event type, must be `input_audio_buffer.committed`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of the preceding item after which the new item will be inserted. Can be
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub previous_item_id: Option<String>,
}

/// **SIP Only:** Returned when an DTMF event is received.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferDtmfEventReceivedEvent {
    /// The telephone keypad that was pressed by the user.
    pub event: String,
    /// UTC Unix Timestamp when DTMF Event was received by server.
    pub received_at: i64,
    /// The event type, must be `input_audio_buffer.dtmf_event_received`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Sent by the server when in `server_vad` mode to indicate that speech has been
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferSpeechStartedEvent {
    /// Milliseconds from the start of all audio written to the buffer during the
    pub audio_start_ms: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the user message item that will be created when speech stops.
    pub item_id: String,
    /// The event type, must be `input_audio_buffer.speech_started`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned in `server_vad` mode when the server detects the end of speech in
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferSpeechStoppedEvent {
    /// Milliseconds since the session started when speech stopped.
    pub audio_end_ms: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the user message item that will be created.
    pub item_id: String,
    /// The event type, must be `input_audio_buffer.speech_stopped`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the Server VAD timeout is triggered for the input audio buffer.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct InputAudioBufferTimeoutTriggered {
    /// Millisecond offset of audio written to the input audio buffer at the time the
    pub audio_end_ms: i64,
    /// Millisecond offset of audio written to the input audio buffer that was after the
    pub audio_start_ms: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item associated with this segment.
    pub item_id: String,
    /// The event type, must be `input_audio_buffer.timeout_triggered`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A log probability object.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct LogProbProperties {
    /// The token that was used to generate the log probability.
    pub token: String,
    /// The bytes that were used to generate the log probability.
    pub bytes: Vec<i64>,
    /// The log probability of the token.
    pub logprob: f64,
}

/// Returned when listing MCP tools has completed for an item.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpListToolsCompleted {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP list tools item.
    pub item_id: String,
    /// The event type, must be `mcp_list_tools.completed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when listing MCP tools has failed for an item.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpListToolsFailed {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP list tools item.
    pub item_id: String,
    /// The event type, must be `mcp_list_tools.failed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when listing MCP tools is in progress for an item.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpListToolsInProgress {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP list tools item.
    pub item_id: String,
    /// The event type, must be `mcp_list_tools.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// **WebRTC/SIP Only:** Emit to cut off the current audio response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputAudioBufferClearEvent {
    /// The event type, must be `output_audio_buffer.clear`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the client event used for error handling.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RateLimitName {
    #[serde(rename = "requests")]
    Requests,
    #[serde(rename = "tokens")]
    Tokens,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RateLimit {
    /// The maximum allowed value for the rate limit.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub limit: Option<i64>,
    /// The name of the rate limit (`requests`, `tokens`).
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub name: Option<RateLimitName>,
    /// The remaining value before the limit is reached.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub remaining: Option<i64>,
    /// Seconds until the rate limit resets.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reset_seconds: Option<f64>,
}

/// Emitted at the beginning of a Response to indicate the updated rate limits.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RateLimitsUpdatedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// List of rate limit information.
    pub rate_limits: Vec<RateLimit>,
    /// The event type, must be `rate_limits.updated`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Configuration for input and output audio.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeAudioConfig {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<RealtimeAudioConfigInput>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<RealtimeAudioConfigOutput>,
}

/// Configuration for input audio noise reduction.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct NoiseReduction {
    /// Type of noise reduction.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<NoiseReductionType>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeAudioConfigInput {
    /// The format of the input audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// Configuration for input audio noise reduction.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub noise_reduction: Option<NoiseReduction>,
    /// Configuration for input audio transcription, defaults to off and can be set to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub transcription: Option<AudioTranscription>,
    /// Configuration for turn detection, ether Server VAD or Semantic VAD.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub turn_detection: Option<RealtimeAudioInputTurnDetection>,
}

/// Custom voice reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct VoiceID {
    /// The custom voice ID, e.g. `voice_1234`.
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum Voice {
    Alloy,
    Ash,
    Ballad,
    Coral,
    Echo,
    Sage,
    Shimmer,
    Verse,
    Marin,
    Cedar,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeAudioConfigOutput {
    /// The format of the output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// The speed of the model's spoken response as a multiple of the original speed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub speed: Option<f64>,
    /// The voice the model uses to respond.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub voice: Option<Voice>,
}

/// The PCM audio format. Only a 24kHz sample rate is supported.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioPCM {
    /// The sample rate of the audio. Always `24000`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub rate: Option<String>,
    /// The audio format. Always `audio/pcm`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// The G.711 μ-law format.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioPCMU {
    /// The audio format. Always `audio/pcmu`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// The G.711 A-law format.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioPCMA {
    /// The audio format. Always `audio/pcma`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

pub type RealtimeAudioFormats = serde_json::Value;

/// Server-side voice activity detection (VAD) which flips on when user speech is detected and off after a period of silence.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ServerVad {
    /// Type of turn detection, `server_vad` to turn on simple Server VAD.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether or not to automatically generate a response when a VAD stop event
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub create_response: Option<bool>,
    /// Optional timeout after which a model response will be triggered automatically.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub idle_timeout_ms: Option<i64>,
    /// Whether or not to automatically interrupt (cancel) any ongoing response with
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub interrupt_response: Option<bool>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prefix_padding_ms: Option<i64>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub silence_duration_ms: Option<i64>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub threshold: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum SemanticVadEagerness {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

/// Server-side semantic turn detection which uses a model to determine when the user has finished speaking.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct SemanticVad {
    /// Type of turn detection, `semantic_vad` to turn on Semantic VAD.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether or not to automatically generate a response when a VAD stop event
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub create_response: Option<bool>,
    /// Used only for `semantic_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub eagerness: Option<SemanticVadEagerness>,
    /// Whether or not to automatically interrupt any ongoing response with output to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub interrupt_response: Option<bool>,
}

pub type RealtimeAudioInputTurnDetection = serde_json::Value;

pub type RealtimeClientEvent = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConnectParams {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub call_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationContentType {
    #[serde(rename = "output_text")]
    OutputText,
    #[serde(rename = "output_audio")]
    OutputAudio,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationContent {
    /// Base64-encoded audio bytes, these will be parsed as the format specified in the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<String>,
    /// The text content.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<String>,
    /// The transcript of the audio content, this will always be present if the output
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub transcript: Option<String>,
    /// The content type, `output_text` or `output_audio` depending on the session
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<RealtimeConversationContentType>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationItemAssistantMessageStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "in_progress")]
    InProgress,
}

/// An assistant message item in a Realtime conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationItemAssistantMessage {
    /// The content of the message.
    pub content: Vec<RealtimeConversationContent>,
    /// The role of the message sender. Always `assistant`.
    pub role: String,
    /// The type of the item. Always `message`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Identifier for the API object being returned - always `realtime.item`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The status of the item. Has no effect on the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeConversationItemAssistantMessageStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationItemFunctionCallStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "in_progress")]
    InProgress,
}

/// A function call item in a Realtime conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationItemFunctionCall {
    /// The arguments of the function call.
    pub arguments: String,
    /// The name of the function being called.
    pub name: String,
    /// The type of the item. Always `function_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// The ID of the function call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub call_id: Option<String>,
    /// Identifier for the API object being returned - always `realtime.item`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The status of the item. Has no effect on the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeConversationItemFunctionCallStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationItemFunctionCallOutputStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "in_progress")]
    InProgress,
}

/// A function call output item in a Realtime conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationItemFunctionCallOutput {
    /// The ID of the function call this output is for.
    pub call_id: String,
    /// The output of the function call, this is free text and can contain any
    pub output: String,
    /// The type of the item. Always `function_call_output`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Identifier for the API object being returned - always `realtime.item`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The status of the item. Has no effect on the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeConversationItemFunctionCallOutputStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationItemSystemMessageStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "in_progress")]
    InProgress,
}

/// A system message in a Realtime conversation can be used to provide additional context or instructions to the model. This is similar but distinct from the instruction prompt provided at the start of a conversation, as system messages can be added at any point in the conversation. For major changes to the conversation's behavior, use instructions, but for smaller updates (e.g. "the user is now asking about a different topic"), use system messages.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationItemSystemMessage {
    /// The content of the message.
    pub content: Vec<RealtimeConversationContent>,
    /// The role of the message sender. Always `system`.
    pub role: String,
    /// The type of the item. Always `message`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Identifier for the API object being returned - always `realtime.item`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The status of the item. Has no effect on the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeConversationItemSystemMessageStatus>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationContentDetail {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "high")]
    High,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeConversationItemUserMessageStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "in_progress")]
    InProgress,
}

/// A user message item in a Realtime conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeConversationItemUserMessage {
    /// The content of the message.
    pub content: Vec<RealtimeConversationContent>,
    /// The role of the message sender. Always `user`.
    pub role: String,
    /// The type of the item. Always `message`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the item.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Identifier for the API object being returned - always `realtime.item`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The status of the item. Has no effect on the conversation.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeConversationItemUserMessageStatus>,
}

/// Details of the error.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeError {
    /// A human-readable error message.
    pub message: String,
    /// The type of error (e.g., "invalid_request_error", "server_error").
    #[serde(rename = "type")]
    pub type_: String,
    /// Error code, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// The event_id of the client event that caused the error, if applicable.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
    /// Parameter related to the error, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub param: Option<String>,
}

/// Returned when an error occurs, which could be a client problem or a server
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeErrorEvent {
    /// Details of the error.
    pub error: RealtimeError,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The event type, must be `error`.
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeFunctionTool {
    /// The description of the function, including guidance on when and how to call it,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
    /// The name of the function.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub name: Option<String>,
    /// Parameters of the function in JSON Schema.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub parameters: Option<serde_json::Value>,
    /// The type of the tool, i.e. `function`.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

/// A Realtime item requesting human approval of a tool invocation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpApprovalRequest {
    /// The unique ID of the approval request.
    pub id: String,
    /// A JSON string of arguments for the tool.
    pub arguments: String,
    /// The name of the tool to run.
    pub name: String,
    /// The label of the MCP server making the request.
    pub server_label: String,
    /// The type of the item. Always `mcp_approval_request`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// A Realtime item responding to an MCP approval request.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpApprovalResponse {
    /// The unique ID of the approval response.
    pub id: String,
    /// The ID of the approval request being answered.
    pub approval_request_id: String,
    /// Whether the request was approved.
    pub approve: bool,
    /// The type of the item. Always `mcp_approval_response`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional reason for the decision.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reason: Option<String>,
}

/// A tool available on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpTool {
    /// The JSON schema describing the tool's input.
    pub input_schema: serde_json::Value,
    /// The name of the tool.
    pub name: String,
    /// Additional annotations about the tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub annotations: Option<serde_json::Value>,
    /// The description of the tool.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub description: Option<String>,
}

/// A Realtime item listing tools available on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpListTools {
    /// The label of the MCP server.
    pub server_label: String,
    /// The tools available on the server.
    pub tools: Vec<RealtimeMcpTool>,
    /// The type of the item. Always `mcp_list_tools`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The unique ID of the list.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpProtocolError {
    pub code: i64,
    pub message: String,
    #[serde(rename = "type")]
    pub type_: String,
}

pub type Error = serde_json::Value;

/// A Realtime item representing an invocation of a tool on an MCP server.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpToolCall {
    /// The unique ID of the tool call.
    pub id: String,
    /// A JSON string of the arguments passed to the tool.
    pub arguments: String,
    /// The name of the tool that was run.
    pub name: String,
    /// The label of the MCP server running the tool.
    pub server_label: String,
    /// The type of the item. Always `mcp_call`.
    #[serde(rename = "type")]
    pub type_: String,
    /// The ID of an associated approval request, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub approval_request_id: Option<String>,
    /// The error from the tool call, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub error: Option<Error>,
    /// The output from the tool call.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcpToolExecutionError {
    pub message: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeMcphttpError {
    pub code: i64,
    pub message: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioOutput {
    /// The format of the output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// The voice the model uses to respond.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub voice: Option<String>,
}

/// Configuration for audio output.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Audio {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<AudioOutput>,
}

/// The response resource.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponse {
    /// The unique ID of the response, will look like `resp_1234`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub id: Option<String>,
    /// Configuration for audio output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<Audio>,
    /// Which conversation the response is added to, determined by the `conversation`
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub conversation_id: Option<String>,
    /// Maximum number of output tokens for a single assistant response, inclusive of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<String>,
    /// Set of 16 key-value pairs that can be attached to an object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// The object type, must be `realtime.response`.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub object: Option<String>,
    /// The list of output items generated by the response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<Vec<ConversationItem>>,
    /// The set of modalities the model used to respond, currently the only possible
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_modalities: Option<Vec<serde_json::Value>>,
    /// The final status of the response (`completed`, `cancelled`, `failed`, or
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status: Option<RealtimeResponseStatus>,
    /// Additional details about the status.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub status_details: Option<RealtimeResponseStatus>,
    /// Usage statistics for the Response, this will correspond to billing.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub usage: Option<RealtimeResponseUsage>,
}

/// Custom voice reference.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputVoiceID {
    /// The custom voice ID, e.g. `voice_1234`.
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum OutputVoice {
    Alloy,
    Ash,
    Ballad,
    Coral,
    Echo,
    Sage,
    Shimmer,
    Verse,
    Marin,
    Cedar,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseOutput {
    /// The format of the output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// The voice the model uses to respond.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub voice: Option<OutputVoice>,
}

/// Configuration for audio input and output.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseCreateAudioOutput {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output: Option<RealtimeResponseOutput>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AllowedToolsMcpToolFilter {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

pub type AllowedTools = serde_json::Value;

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RequireApprovalMcpToolApprovalFilterAlways {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RequireApprovalMcpToolApprovalFilterNever {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// Specify which of the MCP server's tools require approval.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RequireApprovalMcpToolApprovalFilter {
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub always: Option<RequireApprovalMcpToolApprovalFilterAlways>,
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub never: Option<RequireApprovalMcpToolApprovalFilterNever>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RequireApproval {
    Always,
    Never,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeResponseCreateMcpToolConnectorId {
    #[serde(rename = "connector_dropbox")]
    ConnectorDropbox,
    #[serde(rename = "connector_gmail")]
    ConnectorGmail,
    #[serde(rename = "connector_googlecalendar")]
    ConnectorGooglecalendar,
    #[serde(rename = "connector_googledrive")]
    ConnectorGoogledrive,
    #[serde(rename = "connector_microsoftteams")]
    ConnectorMicrosoftteams,
    #[serde(rename = "connector_outlookcalendar")]
    ConnectorOutlookcalendar,
    #[serde(rename = "connector_outlookemail")]
    ConnectorOutlookemail,
    #[serde(rename = "connector_sharepoint")]
    ConnectorSharepoint,
}

/// Give the model access to additional tools via remote Model Context Protocol
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseCreateMcpTool {
    /// A label for this MCP server, used to identify it in tool calls.
    pub server_label: String,
    /// The type of the MCP tool. Always `mcp`.
    #[serde(rename = "type")]
    pub type_: String,
    /// List of allowed tool names or a filter object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub allowed_tools: Option<AllowedTools>,
    /// An OAuth access token that can be used with a remote MCP server, either with a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub authorization: Option<String>,
    /// Identifier for service connectors, like those available in ChatGPT.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub connector_id: Option<RealtimeResponseCreateMcpToolConnectorId>,
    /// Whether this MCP tool is deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    /// Optional HTTP headers to send to the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub headers: Option<std::collections::HashMap<String, String>>,
    /// Specify which of the MCP server's tools require approval.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub require_approval: Option<RequireApproval>,
    /// Optional description of the MCP server, used to provide more context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_description: Option<String>,
    /// The URL for the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_url: Option<String>,
}

pub type ToolChoice = serde_json::Value;

pub type Tool = serde_json::Value;

/// Create a new Realtime response with these parameters
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseCreateParams {
    /// Configuration for audio input and output.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<RealtimeResponseCreateAudioOutput>,
    /// Controls which conversation the response is added to.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub conversation: Option<String>,
    /// Input items to include in the prompt for the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<Vec<ConversationItem>>,
    /// The default system instructions (i.e.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// Maximum number of output tokens for a single assistant response, inclusive of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<String>,
    /// Set of 16 key-value pairs that can be attached to an object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// The set of modalities the model used to respond, currently the only possible
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_modalities: Option<Vec<serde_json::Value>>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<serde_json::Value>,
    /// How the model chooses tools.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<ToolChoice>,
    /// Tools available to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<Vec<RealtimeMcpTool>>,
}

/// A description of the error that caused the response to fail,
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseError {
    /// Error code, if any.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub code: Option<String>,
    /// The type of error.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeResponseStatusReason {
    #[serde(rename = "turn_detected")]
    TurnDetected,
    #[serde(rename = "client_cancelled")]
    ClientCancelled,
    #[serde(rename = "max_output_tokens")]
    MaxOutputTokens,
    #[serde(rename = "content_filter")]
    ContentFilter,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeResponseStatusType {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "incomplete")]
    Incomplete,
    #[serde(rename = "failed")]
    Failed,
}

/// Additional details about the status.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseStatus {
    /// A description of the error that caused the response to fail, populated when the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub error: Option<Error>,
    /// The reason the Response did not complete.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub reason: Option<RealtimeResponseStatusReason>,
    /// The type of error that caused the response to fail, corresponding with the
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<RealtimeResponseStatusType>,
}

/// Usage statistics for the Response, this will correspond to billing.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseUsage {
    /// Details about the input tokens used in the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_token_details: Option<RealtimeResponseUsageInputTokenDetails>,
    /// The number of input tokens used in the Response, including text and audio
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input_tokens: Option<i64>,
    /// Details about the output tokens used in the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_token_details: Option<RealtimeResponseUsageOutputTokenDetails>,
    /// The number of output tokens sent in the Response, including text and audio
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_tokens: Option<i64>,
    /// The total number of tokens in the Response including input and output text and
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub total_tokens: Option<i64>,
}

/// Details about the cached tokens used as input for the Response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct CachedTokensDetails {
    /// The number of cached audio tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio_tokens: Option<i64>,
    /// The number of cached image tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_tokens: Option<i64>,
    /// The number of cached text tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text_tokens: Option<i64>,
}

/// Details about the input tokens used in the Response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseUsageInputTokenDetails {
    /// The number of audio tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio_tokens: Option<i64>,
    /// The number of cached tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub cached_tokens: Option<i64>,
    /// Details about the cached tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub cached_tokens_details: Option<CachedTokensDetails>,
    /// The number of image tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub image_tokens: Option<i64>,
    /// The number of text tokens used as input for the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text_tokens: Option<i64>,
}

/// Details about the output tokens used in the Response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeResponseUsageOutputTokenDetails {
    /// The number of audio tokens used in the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio_tokens: Option<i64>,
    /// The number of text tokens used in the Response.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text_tokens: Option<i64>,
}

/// Returned when a conversation item is retrieved with `conversation.item.retrieve`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ConversationItemRetrieved {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The event type, must be `conversation.item.retrieved`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// **WebRTC/SIP Only:** Emitted when the server begins streaming audio to the client. This event is
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputAudioBufferStarted {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The unique ID of the response that produced the audio.
    pub response_id: String,
    /// The event type, must be `output_audio_buffer.started`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// **WebRTC/SIP Only:** Emitted when the output audio buffer has been completely drained on the server,
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputAudioBufferStopped {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The unique ID of the response that produced the audio.
    pub response_id: String,
    /// The event type, must be `output_audio_buffer.stopped`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// **WebRTC/SIP Only:** Emitted when the output audio buffer is cleared.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct OutputAudioBufferCleared {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The unique ID of the response that produced the audio.
    pub response_id: String,
    /// The event type, must be `output_audio_buffer.cleared`.
    #[serde(rename = "type")]
    pub type_: String,
}

pub type RealtimeServerEvent = serde_json::Value;

/// Ephemeral key returned by the API.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeSessionClientSecret {
    /// Timestamp for when the token expires.
    pub expires_at: i64,
    /// Ephemeral key usable in client environments to authenticate connections to the
    pub value: String,
}

/// Realtime session object configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeSessionCreateRequest {
    /// The type of session to create. Always `realtime` for the Realtime API.
    #[serde(rename = "type")]
    pub type_: String,
    /// Configuration for input and output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<RealtimeAudioConfig>,
    /// Additional fields to include in server outputs.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<String>>,
    /// The default system instructions (i.e.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// Maximum number of output tokens for a single assistant response, inclusive of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<String>,
    /// The Realtime model used for this session.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// The set of modalities the model can respond with.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_modalities: Option<Vec<serde_json::Value>>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<serde_json::Value>,
    /// How the model chooses tools.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<RealtimeToolChoiceConfig>,
    /// Tools available to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<RealtimeToolsConfig>,
    /// Realtime API can write session traces to the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tracing: Option<RealtimeTracingConfig>,
    /// When the number of tokens in a conversation exceeds the model's input token
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<RealtimeTruncation>,
}

/// Configuration for input audio noise reduction.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioInputNoiseReduction {
    /// Type of noise reduction.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<NoiseReductionType>,
}

/// Server-side voice activity detection (VAD) which flips on when user speech is detected and off after a period of silence.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioInputTurnDetectionServerVad {
    /// Type of turn detection, `server_vad` to turn on simple Server VAD.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether or not to automatically generate a response when a VAD stop event
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub create_response: Option<bool>,
    /// Optional timeout after which a model response will be triggered automatically.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub idle_timeout_ms: Option<i64>,
    /// Whether or not to automatically interrupt (cancel) any ongoing response with
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub interrupt_response: Option<bool>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prefix_padding_ms: Option<i64>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub silence_duration_ms: Option<i64>,
    /// Used only for `server_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub threshold: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum AudioInputTurnDetectionSemanticVadEagerness {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "auto")]
    Auto,
}

/// Server-side semantic turn detection which uses a model to determine when the user has finished speaking.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioInputTurnDetectionSemanticVad {
    /// Type of turn detection, `semantic_vad` to turn on Semantic VAD.
    #[serde(rename = "type")]
    pub type_: String,
    /// Whether or not to automatically generate a response when a VAD stop event
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub create_response: Option<bool>,
    /// Used only for `semantic_vad` mode.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub eagerness: Option<AudioInputTurnDetectionSemanticVadEagerness>,
    /// Whether or not to automatically interrupt any ongoing response with output to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub interrupt_response: Option<bool>,
}

pub type AudioInputTurnDetection = serde_json::Value;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct AudioInput {
    /// The format of the input audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// Configuration for input audio noise reduction.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub noise_reduction: Option<AudioInputNoiseReduction>,
    /// Configuration for input audio transcription, defaults to off and can be set to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub transcription: Option<AudioTranscription>,
    /// Configuration for turn detection, ether Server VAD or Semantic VAD.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub turn_detection: Option<AudioInputTurnDetection>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolMcpToolAllowedToolsMcpToolFilter {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

pub type ToolMcpToolAllowedTools = serde_json::Value;

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolMcpToolRequireApprovalMcpToolApprovalFilterAlways {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolMcpToolRequireApprovalMcpToolApprovalFilterNever {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// Specify which of the MCP server's tools require approval.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolMcpToolRequireApprovalMcpToolApprovalFilter {
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub always: Option<ToolMcpToolRequireApprovalMcpToolApprovalFilterAlways>,
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub never: Option<ToolMcpToolRequireApprovalMcpToolApprovalFilterNever>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolMcpToolRequireApproval {
    Always,
    Never,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ToolMcpToolConnectorId {
    #[serde(rename = "connector_dropbox")]
    ConnectorDropbox,
    #[serde(rename = "connector_gmail")]
    ConnectorGmail,
    #[serde(rename = "connector_googlecalendar")]
    ConnectorGooglecalendar,
    #[serde(rename = "connector_googledrive")]
    ConnectorGoogledrive,
    #[serde(rename = "connector_microsoftteams")]
    ConnectorMicrosoftteams,
    #[serde(rename = "connector_outlookcalendar")]
    ConnectorOutlookcalendar,
    #[serde(rename = "connector_outlookemail")]
    ConnectorOutlookemail,
    #[serde(rename = "connector_sharepoint")]
    ConnectorSharepoint,
}

/// Give the model access to additional tools via remote Model Context Protocol
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ToolMcpTool {
    /// A label for this MCP server, used to identify it in tool calls.
    pub server_label: String,
    /// The type of the MCP tool. Always `mcp`.
    #[serde(rename = "type")]
    pub type_: String,
    /// List of allowed tool names or a filter object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub allowed_tools: Option<ToolMcpToolAllowedTools>,
    /// An OAuth access token that can be used with a remote MCP server, either with a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub authorization: Option<String>,
    /// Identifier for service connectors, like those available in ChatGPT.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub connector_id: Option<ToolMcpToolConnectorId>,
    /// Whether this MCP tool is deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    /// Optional HTTP headers to send to the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub headers: Option<std::collections::HashMap<String, String>>,
    /// Specify which of the MCP server's tools require approval.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub require_approval: Option<ToolMcpToolRequireApproval>,
    /// Optional description of the MCP server, used to provide more context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_description: Option<String>,
    /// The URL for the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_url: Option<String>,
}

/// Granular configuration for tracing.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct TracingTracingConfiguration {
    /// The group id to attach to this trace to enable filtering and grouping in the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub group_id: Option<String>,
    /// The arbitrary metadata to attach to this trace to enable filtering in the Traces
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// The name of the workflow to attach to this trace.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub workflow_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum Tracing {
    Auto,
}

/// A new Realtime session configuration, with an ephemeral key.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeSessionCreateResponse {
    /// Ephemeral key returned by the API.
    pub client_secret: RealtimeSessionClientSecret,
    /// The type of session to create. Always `realtime` for the Realtime API.
    #[serde(rename = "type")]
    pub type_: String,
    /// Configuration for input and output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<Audio>,
    /// Additional fields to include in server outputs.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<String>>,
    /// The default system instructions (i.e.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub instructions: Option<String>,
    /// Maximum number of output tokens for a single assistant response, inclusive of
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub max_output_tokens: Option<String>,
    /// The Realtime model used for this session.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub model: Option<String>,
    /// The set of modalities the model can respond with.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub output_modalities: Option<Vec<serde_json::Value>>,
    /// Reference to a prompt template and its variables.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt: Option<serde_json::Value>,
    /// How the model chooses tools.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_choice: Option<ToolChoice>,
    /// Tools available to the model.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tools: Option<Vec<RealtimeMcpTool>>,
    /// Realtime API can write session traces to the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tracing: Option<Tracing>,
    /// When the number of tokens in a conversation exceeds the model's input token
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub truncation: Option<RealtimeTruncation>,
}

pub type RealtimeToolChoiceConfig = serde_json::Value;

pub type RealtimeToolsConfig = Vec<RealtimeToolsConfigUnion>;

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpAllowedToolsMcpToolFilter {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

pub type McpAllowedTools = serde_json::Value;

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilterAlways {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// A filter object to specify which tools are allowed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilterNever {
    /// Indicates whether or not a tool modifies data or is read-only.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub read_only: Option<bool>,
    /// List of allowed tool names.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub tool_names: Option<Vec<String>>,
}

/// Specify which of the MCP server's tools require approval.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct McpRequireApprovalMcpToolApprovalFilter {
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub always: Option<McpRequireApprovalMcpToolApprovalFilterAlways>,
    /// A filter object to specify which tools are allowed.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub never: Option<McpRequireApprovalMcpToolApprovalFilterNever>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum McpRequireApproval {
    Always,
    Never,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum McpConnectorId {
    #[serde(rename = "connector_dropbox")]
    ConnectorDropbox,
    #[serde(rename = "connector_gmail")]
    ConnectorGmail,
    #[serde(rename = "connector_googlecalendar")]
    ConnectorGooglecalendar,
    #[serde(rename = "connector_googledrive")]
    ConnectorGoogledrive,
    #[serde(rename = "connector_microsoftteams")]
    ConnectorMicrosoftteams,
    #[serde(rename = "connector_outlookcalendar")]
    ConnectorOutlookcalendar,
    #[serde(rename = "connector_outlookemail")]
    ConnectorOutlookemail,
    #[serde(rename = "connector_sharepoint")]
    ConnectorSharepoint,
}

/// Give the model access to additional tools via remote Model Context Protocol
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct Mcp {
    /// A label for this MCP server, used to identify it in tool calls.
    pub server_label: String,
    /// The type of the MCP tool. Always `mcp`.
    #[serde(rename = "type")]
    pub type_: String,
    /// List of allowed tool names or a filter object.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub allowed_tools: Option<McpAllowedTools>,
    /// An OAuth access token that can be used with a remote MCP server, either with a
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub authorization: Option<String>,
    /// Identifier for service connectors, like those available in ChatGPT.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub connector_id: Option<McpConnectorId>,
    /// Whether this MCP tool is deferred and discovered via tool search.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub defer_loading: Option<bool>,
    /// Optional HTTP headers to send to the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub headers: Option<std::collections::HashMap<String, String>>,
    /// Specify which of the MCP server's tools require approval.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub require_approval: Option<McpRequireApproval>,
    /// Optional description of the MCP server, used to provide more context.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_description: Option<String>,
    /// The URL for the MCP server.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub server_url: Option<String>,
}

pub type RealtimeToolsConfigUnion = serde_json::Value;

/// Granular configuration for tracing.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct TracingConfiguration {
    /// The group id to attach to this trace to enable filtering and grouping in the
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub group_id: Option<String>,
    /// The arbitrary metadata to attach to this trace to enable filtering in the Traces
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub metadata: Option<serde_json::Value>,
    /// The name of the workflow to attach to this trace.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub workflow_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeTracingConfig {
    Auto,
}

/// Configuration for input and output audio.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTranscriptionSessionAudio {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub input: Option<RealtimeTranscriptionSessionAudioInput>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTranscriptionSessionAudioInput {
    /// The PCM audio format. Only a 24kHz sample rate is supported.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub format: Option<RealtimeAudioFormats>,
    /// Configuration for input audio noise reduction.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub noise_reduction: Option<NoiseReduction>,
    /// Configuration for input audio transcription, defaults to off and can be set to
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub transcription: Option<AudioTranscription>,
    /// Configuration for turn detection, ether Server VAD or Semantic VAD.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub turn_detection: Option<RealtimeTranscriptionSessionAudioInputTurnDetection>,
}

pub type RealtimeTranscriptionSessionAudioInputTurnDetection = serde_json::Value;

/// Realtime transcription session object configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTranscriptionSessionCreateRequest {
    /// The type of session to create.
    #[serde(rename = "type")]
    pub type_: String,
    /// Configuration for input and output audio.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<RealtimeTranscriptionSessionAudio>,
    /// Additional fields to include in server outputs.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<String>>,
}

/// A Realtime transcription session configuration object.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTranscriptionSessionCreateResponse {
    /// Unique identifier for the session that looks like `sess_1234567890abcdef`.
    pub id: String,
    /// The object type. Always `realtime.transcription_session`.
    pub object: String,
    /// The type of session. Always `transcription` for transcription sessions.
    #[serde(rename = "type")]
    pub type_: String,
    /// Configuration for input audio for the session.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<Audio>,
    /// Expiration timestamp for the session, in seconds since epoch.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub expires_at: Option<i64>,
    /// Additional fields to include in server outputs.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub include: Option<Vec<String>>,
}

/// Configuration for turn detection.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTranscriptionSessionTurnDetection {
    /// Amount of audio to include before the VAD detected speech (in milliseconds).
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prefix_padding_ms: Option<i64>,
    /// Duration of silence to detect speech stop (in milliseconds).
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub silence_duration_ms: Option<i64>,
    /// Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub threshold: Option<f64>,
    /// Type of turn detection, only `server_vad` is currently supported.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum RealtimeTruncation {
    Auto,
    Disabled,
}

/// Optional custom token limits for this truncation strategy.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct TokenLimits {
    /// Maximum tokens allowed in the conversation after instructions (which including
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub post_instructions: Option<i64>,
}

/// Retain a fraction of the conversation tokens when the conversation exceeds the input token limit. This allows you to amortize truncations across multiple turns, which can help improve cached token usage.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct RealtimeTruncationRetentionRatio {
    /// Fraction of post-instruction conversation tokens to retain (`0.0` - `1.0`) when
    pub retention_ratio: f64,
    /// Use retention ratio truncation.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional custom token limits for this truncation strategy.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub token_limits: Option<TokenLimits>,
}

/// Returned when the model-generated audio is updated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioDeltaEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// Base64-encoded audio data delta.
    pub delta: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.output_audio.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the model-generated audio is done.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioDoneEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.output_audio.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the model-generated transcription of audio output is updated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioTranscriptDeltaEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The transcript delta.
    pub delta: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.output_audio_transcript.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the model-generated transcription of audio output is done
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseAudioTranscriptDoneEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The final transcript of the audio.
    pub transcript: String,
    /// The event type, must be `response.output_audio_transcript.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Send this event to cancel an in-progress response.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCancelEvent {
    /// The event type, must be `response.cancel`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
    /// A specific response ID to cancel - if not provided, will cancel an in-progress
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub response_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
#[non_exhaustive]
pub enum ContentPartPartType {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "audio")]
    Audio,
}

/// The content part that was added.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ContentPartPart {
    /// Base64-encoded audio data (if type is "audio").
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub audio: Option<String>,
    /// The text content (if type is "text").
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub text: Option<String>,
    /// The transcript of the audio (if type is "audio").
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub transcript: Option<String>,
    /// The content type ("text", "audio").
    #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
    pub type_: Option<ContentPartPartType>,
}

/// Returned when a new content part is added to an assistant message item during
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseContentPartAddedEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item to which the content part was added.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The content part that was added.
    pub part: ContentPartPart,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.content_part.added`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when a content part is done streaming in an assistant message item.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseContentPartDoneEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The content part that is done.
    pub part: ContentPartPart,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.content_part.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// This event instructs the server to create a Response, which means triggering
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCreateEvent {
    /// The event type, must be `response.create`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
    /// Create a new Realtime response with these parameters
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub response: Option<RealtimeResponseCreateParams>,
}

/// Returned when a new Response is created.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseCreatedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The response resource.
    pub response: RealtimeResponse,
    /// The event type, must be `response.created`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when a Response is done streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseDoneEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The response resource.
    pub response: RealtimeResponse,
    /// The event type, must be `response.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the model-generated function call arguments are updated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionCallArgumentsDeltaEvent {
    /// The ID of the function call.
    pub call_id: String,
    /// The arguments delta as a JSON string.
    pub delta: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the function call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.function_call_arguments.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the model-generated function call arguments are done streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseFunctionCallArgumentsDoneEvent {
    /// The final arguments as a JSON string.
    pub arguments: String,
    /// The ID of the function call.
    pub call_id: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the function call item.
    pub item_id: String,
    /// The name of the function that was called.
    pub name: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.function_call_arguments.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when MCP tool call arguments are updated during response generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallArgumentsDelta {
    /// The JSON-encoded arguments delta.
    pub delta: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP tool call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.mcp_call_arguments.delta`.
    #[serde(rename = "type")]
    pub type_: String,
    /// If present, indicates the delta text was obfuscated.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub obfuscation: Option<String>,
}

/// Returned when MCP tool call arguments are finalized during response generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallArgumentsDone {
    /// The final JSON-encoded arguments string.
    pub arguments: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP tool call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.mcp_call_arguments.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when an MCP tool call has completed successfully.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallCompleted {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP tool call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The event type, must be `response.mcp_call.completed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when an MCP tool call has failed.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallFailed {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP tool call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The event type, must be `response.mcp_call.failed`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when an MCP tool call has started and is in progress.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseMcpCallInProgress {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the MCP tool call item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The event type, must be `response.mcp_call.in_progress`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when a new Item is created during Response generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputItemAddedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The index of the output item in the Response.
    pub output_index: i64,
    /// The ID of the Response to which the item belongs.
    pub response_id: String,
    /// The event type, must be `response.output_item.added`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when an Item is done streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseOutputItemDoneEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// A single item within a Realtime conversation.
    pub item: ConversationItem,
    /// The index of the output item in the Response.
    pub output_index: i64,
    /// The ID of the Response to which the item belongs.
    pub response_id: String,
    /// The event type, must be `response.output_item.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the text value of an "output_text" content part is updated.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseTextDeltaEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The text delta.
    pub delta: String,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The event type, must be `response.output_text.delta`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when the text value of an "output_text" content part is done streaming.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct ResponseTextDoneEvent {
    /// The index of the content part in the item's content array.
    pub content_index: i64,
    /// The unique ID of the server event.
    pub event_id: String,
    /// The ID of the item.
    pub item_id: String,
    /// The index of the output item in the response.
    pub output_index: i64,
    /// The ID of the response.
    pub response_id: String,
    /// The final text content.
    pub text: String,
    /// The event type, must be `response.output_text.done`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Returned when a Session is created.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct SessionCreatedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The session configuration.
    pub session: Session,
    /// The event type, must be `session.created`.
    #[serde(rename = "type")]
    pub type_: String,
}

/// Send this event to update the session’s configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct SessionUpdateEvent {
    /// Update the Realtime session.
    pub session: Session,
    /// The event type, must be `session.update`.
    #[serde(rename = "type")]
    pub type_: String,
    /// Optional client-generated ID used to identify this event.
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub event_id: Option<String>,
}

/// Returned when a session is updated with a `session.update` event, unless
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
pub struct SessionUpdatedEvent {
    /// The unique ID of the server event.
    pub event_id: String,
    /// The session configuration.
    pub session: Session,
    /// The event type, must be `session.updated`.
    #[serde(rename = "type")]
    pub type_: String,
}