ghl-sdk 0.5.2

// @generated by xtask/generate_services.py — do not edit by hand.
//! `conversations` — typed methods for all 25 API v3 operations
//! in this module.
//!
//! Access via [`Ghl::v3`](crate::Ghl::v3)`().conversations()`. These endpoints send `Version: v3`.
//!
//! Request and response types come from [`ghl_models::v3::conversations`](https://docs.rs/ghl-models/latest/ghl_models/v3/conversations/); every endpoint is also documented in the
//! [`conversations` API reference](https://github.com/Shahroz/ghl-rs/blob/main/docs/api/conversations.md).
//!
//! Enable with `features = ["conversations"]`.

#![allow(clippy::too_many_arguments)]

use crate::client::Ghl;
use crate::error::Result;
use ghl_models::v3::conversations as models;

/// Typed access to the `conversations` API v3 surface (25 operations). Obtained via
/// [`Ghl::v3`](crate::Ghl::v3)`().conversations()`.
#[derive(Debug, Clone)]
pub struct ConversationsService {
    pub(crate) client: Ghl,
}

impl ConversationsService {
    pub(crate) fn new(client: Ghl) -> Self {
        Self { client }
    }
}

/// Query parameters for [`ConversationsService::export_messages_by_location_id`].
#[derive(Debug, Clone, Default)]
pub struct ExportMessagesByLocationIdParams {
    /// Location ID to filter messages by
    /// Required by the API.
    pub location_id: String,
    /// Number of messages to return per page
    pub limit: Option<f64>,
    /// Cursor for pagination. Pass the nextCursor from previous response to get next page.
    pub cursor: Option<String>,
    /// Field to sort by
    /// Allowed values: `createdAt`, `updatedAt`.
    pub sort_by: Option<String>,
    /// Sort order
    /// Allowed values: `asc`, `desc`.
    pub sort_order: Option<String>,
    /// Filter messages by conversation ID
    pub conversation_id: Option<String>,
    /// Filter messages by contact ID
    pub contact_id: Option<String>,
    /// Filter by message channel. Optional - when not provided, all non-email message types
    /// will be returned including activity messages (opportunity updates, appointments,
    /// etc.). To fetch email messages, you must explicitly set channel=Email.
    /// Allowed values: `Call`, `SMS`, `Email`, `WhatsApp`, `Instagram`, `Facebook`.
    pub channel: Option<String>,
    /// Start date to filter messages by
    pub start_date: Option<String>,
    /// End date to filter messages by
    pub end_date: Option<String>,
}

impl ExportMessagesByLocationIdParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// Number of messages to return per page
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// Cursor for pagination. Pass the nextCursor from previous response to get next page.
    pub fn cursor(mut self, v: impl Into<String>) -> Self {
        self.cursor = Some(v.into());
        self
    }

    /// Field to sort by
    pub fn sort_by(mut self, v: impl Into<String>) -> Self {
        self.sort_by = Some(v.into());
        self
    }

    /// Sort order
    pub fn sort_order(mut self, v: impl Into<String>) -> Self {
        self.sort_order = Some(v.into());
        self
    }

    /// Filter messages by conversation ID
    pub fn conversation_id(mut self, v: impl Into<String>) -> Self {
        self.conversation_id = Some(v.into());
        self
    }

    /// Filter messages by contact ID
    pub fn contact_id(mut self, v: impl Into<String>) -> Self {
        self.contact_id = Some(v.into());
        self
    }

    /// Filter by message channel. Optional - when not provided, all non-email message types
    /// will be returned including activity messages (opportunity updates, appointments,
    /// etc.). To fetch email messages, you must explicitly set channel=Email.
    pub fn channel(mut self, v: impl Into<String>) -> Self {
        self.channel = Some(v.into());
        self
    }

    /// Start date to filter messages by
    pub fn start_date(mut self, v: impl Into<String>) -> Self {
        self.start_date = Some(v.into());
        self
    }

    /// End date to filter messages by
    pub fn end_date(mut self, v: impl Into<String>) -> Self {
        self.end_date = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.cursor {
            q.push(("cursor".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_by {
            q.push(("sortBy".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_order {
            q.push(("sortOrder".into(), v.to_string()));
        }
        if let Some(v) = &self.conversation_id {
            q.push(("conversationId".into(), v.to_string()));
        }
        if let Some(v) = &self.contact_id {
            q.push(("contactId".into(), v.to_string()));
        }
        if let Some(v) = &self.channel {
            q.push(("channel".into(), v.to_string()));
        }
        if let Some(v) = &self.start_date {
            q.push(("startDate".into(), v.to_string()));
        }
        if let Some(v) = &self.end_date {
            q.push(("endDate".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ConversationsService::search_conversations`].
#[derive(Debug, Clone, Default)]
pub struct SearchConversationsParams {
    /// Location Id
    /// Required by the API.
    pub location_id: String,
    /// Contact Id
    pub contact_id: Option<String>,
    /// User IDs that conversations are assigned to. Multiple IDs can be provided as
    /// comma-separated values. Use "unassigned" to fetch conversations not assigned to any
    /// user.
    pub assigned_to: Option<String>,
    /// User IDs of followers to filter conversations by. Multiple IDs can be provided as
    /// comma-separated values.
    pub followers: Option<String>,
    /// User Id of the mention. Multiple values are comma separated.
    pub mentions: Option<String>,
    /// Search paramater as a string
    pub query: Option<String>,
    /// Sort paramater - asc or desc
    /// Allowed values: `asc`, `desc`.
    pub sort: Option<String>,
    /// Search to begin after the specified date - should contain the sort value of the last
    /// document
    pub start_after_date: Option<String>,
    /// Id of the conversation
    pub id: Option<String>,
    /// Limit of conversations - Default is 20
    pub limit: Option<f64>,
    /// Type of the last message in the conversation as a string
    /// Allowed values: `TYPE_CALL`, `TYPE_SMS`, `TYPE_RCS`, `TYPE_EMAIL`,
    /// `TYPE_SMS_REVIEW_REQUEST`, `TYPE_WEBCHAT`, `TYPE_SMS_NO_SHOW_REQUEST`,
    /// `TYPE_CAMPAIGN_SMS`, `TYPE_CAMPAIGN_CALL`, `TYPE_CAMPAIGN_EMAIL`.
    pub last_message_type: Option<String>,
    /// Action of the last outbound message in the conversation as string.
    /// Allowed values: `automated`, `manual`.
    pub last_message_action: Option<String>,
    /// Direction of the last message in the conversation as string.
    /// Allowed values: `inbound`, `outbound`.
    pub last_message_direction: Option<String>,
    /// The status of the conversation to be filtered - all, read, unread, starred
    /// Allowed values: `all`, `read`, `unread`, `starred`, `recents`.
    pub status: Option<String>,
    /// The sorting of the conversation to be filtered as - manual messages or all messages
    /// Allowed values: `last_manual_message_date`, `last_message_date`, `score_profile`,
    /// `overdue_at`, `due_at`.
    pub sort_by: Option<String>,
    /// Id of score profile on which sortBy.ScoreProfile should sort on
    pub sort_score_profile: Option<String>,
    /// Id of score profile on which conversations should get filtered out, works with
    /// scoreProfileMin & scoreProfileMax
    pub score_profile: Option<String>,
    /// Minimum value for score
    pub score_profile_min: Option<f64>,
    /// Maximum value for score
    pub score_profile_max: Option<f64>,
    /// Start date filter for dateAdded field (Unix timestamp in milliseconds)
    pub start_date: Option<f64>,
    /// End date filter for dateAdded field (Unix timestamp in milliseconds)
    pub end_date: Option<f64>,
}

impl SearchConversationsParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// Contact Id
    pub fn contact_id(mut self, v: impl Into<String>) -> Self {
        self.contact_id = Some(v.into());
        self
    }

    /// User IDs that conversations are assigned to. Multiple IDs can be provided as
    /// comma-separated values. Use "unassigned" to fetch conversations not assigned to any
    /// user.
    pub fn assigned_to(mut self, v: impl Into<String>) -> Self {
        self.assigned_to = Some(v.into());
        self
    }

    /// User IDs of followers to filter conversations by. Multiple IDs can be provided as
    /// comma-separated values.
    pub fn followers(mut self, v: impl Into<String>) -> Self {
        self.followers = Some(v.into());
        self
    }

    /// User Id of the mention. Multiple values are comma separated.
    pub fn mentions(mut self, v: impl Into<String>) -> Self {
        self.mentions = Some(v.into());
        self
    }

    /// Search paramater as a string
    pub fn query(mut self, v: impl Into<String>) -> Self {
        self.query = Some(v.into());
        self
    }

    /// Sort paramater - asc or desc
    pub fn sort(mut self, v: impl Into<String>) -> Self {
        self.sort = Some(v.into());
        self
    }

    /// Search to begin after the specified date - should contain the sort value of the last
    /// document
    pub fn start_after_date(mut self, v: impl Into<String>) -> Self {
        self.start_after_date = Some(v.into());
        self
    }

    /// Id of the conversation
    pub fn id(mut self, v: impl Into<String>) -> Self {
        self.id = Some(v.into());
        self
    }

    /// Limit of conversations - Default is 20
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// Type of the last message in the conversation as a string
    pub fn last_message_type(mut self, v: impl Into<String>) -> Self {
        self.last_message_type = Some(v.into());
        self
    }

    /// Action of the last outbound message in the conversation as string.
    pub fn last_message_action(mut self, v: impl Into<String>) -> Self {
        self.last_message_action = Some(v.into());
        self
    }

    /// Direction of the last message in the conversation as string.
    pub fn last_message_direction(mut self, v: impl Into<String>) -> Self {
        self.last_message_direction = Some(v.into());
        self
    }

    /// The status of the conversation to be filtered - all, read, unread, starred
    pub fn status(mut self, v: impl Into<String>) -> Self {
        self.status = Some(v.into());
        self
    }

    /// The sorting of the conversation to be filtered as - manual messages or all messages
    pub fn sort_by(mut self, v: impl Into<String>) -> Self {
        self.sort_by = Some(v.into());
        self
    }

    /// Id of score profile on which sortBy.ScoreProfile should sort on
    pub fn sort_score_profile(mut self, v: impl Into<String>) -> Self {
        self.sort_score_profile = Some(v.into());
        self
    }

    /// Id of score profile on which conversations should get filtered out, works with
    /// scoreProfileMin & scoreProfileMax
    pub fn score_profile(mut self, v: impl Into<String>) -> Self {
        self.score_profile = Some(v.into());
        self
    }

    /// Minimum value for score
    pub fn score_profile_min(mut self, v: f64) -> Self {
        self.score_profile_min = Some(v);
        self
    }

    /// Maximum value for score
    pub fn score_profile_max(mut self, v: f64) -> Self {
        self.score_profile_max = Some(v);
        self
    }

    /// Start date filter for dateAdded field (Unix timestamp in milliseconds)
    pub fn start_date(mut self, v: f64) -> Self {
        self.start_date = Some(v);
        self
    }

    /// End date filter for dateAdded field (Unix timestamp in milliseconds)
    pub fn end_date(mut self, v: f64) -> Self {
        self.end_date = Some(v);
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.contact_id {
            q.push(("contactId".into(), v.to_string()));
        }
        if let Some(v) = &self.assigned_to {
            q.push(("assignedTo".into(), v.to_string()));
        }
        if let Some(v) = &self.followers {
            q.push(("followers".into(), v.to_string()));
        }
        if let Some(v) = &self.mentions {
            q.push(("mentions".into(), v.to_string()));
        }
        if let Some(v) = &self.query {
            q.push(("query".into(), v.to_string()));
        }
        if let Some(v) = &self.sort {
            q.push(("sort".into(), v.to_string()));
        }
        if let Some(v) = &self.start_after_date {
            q.push(("startAfterDate".into(), v.to_string()));
        }
        if let Some(v) = &self.id {
            q.push(("id".into(), v.to_string()));
        }
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.last_message_type {
            q.push(("lastMessageType".into(), v.to_string()));
        }
        if let Some(v) = &self.last_message_action {
            q.push(("lastMessageAction".into(), v.to_string()));
        }
        if let Some(v) = &self.last_message_direction {
            q.push(("lastMessageDirection".into(), v.to_string()));
        }
        if let Some(v) = &self.status {
            q.push(("status".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_by {
            q.push(("sortBy".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_score_profile {
            q.push(("sortScoreProfile".into(), v.to_string()));
        }
        if let Some(v) = &self.score_profile {
            q.push(("scoreProfile".into(), v.to_string()));
        }
        if let Some(v) = &self.score_profile_min {
            q.push(("scoreProfileMin".into(), v.to_string()));
        }
        if let Some(v) = &self.score_profile_max {
            q.push(("scoreProfileMax".into(), v.to_string()));
        }
        if let Some(v) = &self.start_date {
            q.push(("startDate".into(), v.to_string()));
        }
        if let Some(v) = &self.end_date {
            q.push(("endDate".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ConversationsService::get_messages_by_conversation_id`].
#[derive(Debug, Clone, Default)]
pub struct GetMessagesByConversationIdParams {
    /// Message ID of the last message in the list as a string
    pub last_message_id: Option<String>,
    /// Number of messages to be fetched from the conversation. Default limit is 20
    pub limit: Option<f64>,
    /// Types of message to fetched separated with comma
    /// Allowed values: `TYPE_CALL`, `TYPE_SMS`, `TYPE_RCS`, `TYPE_EMAIL`, `TYPE_FACEBOOK`,
    /// `TYPE_GMB`, `TYPE_INSTAGRAM`, `TYPE_WHATSAPP`, `TYPE_ACTIVITY_APPOINTMENT`,
    /// `TYPE_ACTIVITY_CONTACT`.
    pub type_: Option<String>,
}

impl GetMessagesByConversationIdParams {
    /// Start from the parameters the API requires.
    pub fn new() -> Self {
        Self {
            ..Default::default()
        }
    }

    /// Message ID of the last message in the list as a string
    pub fn last_message_id(mut self, v: impl Into<String>) -> Self {
        self.last_message_id = Some(v.into());
        self
    }

    /// Number of messages to be fetched from the conversation. Default limit is 20
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// Types of message to fetched separated with comma
    pub fn type_(mut self, v: impl Into<String>) -> Self {
        self.type_ = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = Vec::new();
        if let Some(v) = &self.last_message_id {
            q.push(("lastMessageId".into(), v.to_string()));
        }
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.type_ {
            q.push(("type".into(), v.to_string()));
        }
        q
    }
}

impl ConversationsService {
    /// Create Conversation
    ///
    /// Creates a new conversation with the data provided
    ///
    /// `POST /conversations/`
    ///
    /// Requires scope: `conversations.write`.
    pub async fn create_conversation(
        &self,
        body: &models::CreateConversationDto,
    ) -> Result<models::CreateConversationSuccessResponse> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Get transcription by Message ID
    ///
    /// Get the recording transcription for a message by passing the message id
    ///
    /// `GET /conversations/locations/{locationId}/messages/{messageId}/transcription`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn get_transcription_by_message_id(
        &self,
        location_id: &str,
        message_id: &str,
    ) -> Result<models::GetMessageTranscriptionResponseDto> {
        let path = format!(
            "/conversations/locations/{}/messages/{}/transcription",
            crate::services::encode(location_id),
            crate::services::encode(message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Download transcription by Message ID
    ///
    /// Download the recording transcription for a message by passing the message id
    ///
    /// `GET /conversations/locations/{locationId}/messages/{messageId}/transcription/download`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn download_transcription_by_message_id(
        &self,
        location_id: &str,
        message_id: &str,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/conversations/locations/{}/messages/{}/transcription/download",
            crate::services::encode(location_id),
            crate::services::encode(message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Send a new message
    ///
    /// Post the necessary fields for the API to send a new message.
    ///
    /// `POST /conversations/messages`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn send_a_new_message(
        &self,
        body: &models::SendMessageBodyDto,
    ) -> Result<models::SendMessageResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Cancel a scheduled email message.
    ///
    /// Post the messageId for the API to delete a scheduled email message.
    ///
    /// `DELETE /conversations/messages/email/{emailMessageId}/schedule`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn cancel_a_scheduled_email_message(
        &self,
        email_message_id: &str,
    ) -> Result<models::CancelScheduledResponseDto> {
        let path = format!(
            "/conversations/messages/email/{}/schedule",
            crate::services::encode(email_message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get email by Id
    ///
    /// `GET /conversations/messages/email/{id}`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn get_email_by_id(&self, id: &str) -> Result<models::GetEmailMessageResponseDto> {
        let path = format!(
            "/conversations/messages/email/{}",
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Update email message status
    ///
    /// Update delivery events, per-recipient statuses, and the overall message status for
    /// an email sent via a custom conversation provider. ### Authorization - Requires the
    /// `conversations/message.write` OAuth scope. - The calling OAuth app must own the
    /// conversation provider that originally sent the email. - Attempts to update emails
    /// sent via LC Email or Mailgun will return `403 Forbidden`. ### Updatable Fields
    /// **`status`** is required on every request. You may also include **`events`** and/or
    /// **`recipients`**. **`events`** — Aggregate delivery event counters (integers).
    /// Counters are merged into the e
    ///
    /// `PUT /conversations/messages/email/{id}/status`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn update_email_message_status(
        &self,
        id: &str,
        body: &models::UpdateEmailMessageStatusDto,
    ) -> Result<models::UpdateEmailMessageStatusResponseDto> {
        let path = format!(
            "/conversations/messages/email/{}/status",
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Export messages by location ID
    ///
    /// Export messages for a specific location with cursor-based pagination support.
    /// Response includes messageType (string), source, and subType fields. The channel
    /// parameter is optional - if not provided, all non-email message types will be
    /// returned including activity messages (opportunity updates, appointments, etc.).
    ///
    /// `GET /conversations/messages/export`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn export_messages_by_location_id(
        &self,
        params: &ExportMessagesByLocationIdParams,
    ) -> Result<models::ExportMessagesResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/conversations/messages/export",
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Add an inbound message
    ///
    /// Post the necessary fields for the API to add a new inbound message.
    ///
    /// `POST /conversations/messages/inbound`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn add_an_inbound_message(
        &self,
        body: &models::ProcessMessageBodyDto,
    ) -> Result<models::ProcessMessageResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/inbound",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Add an external outbound call
    ///
    /// Post the necessary fields for the API to add a new outbound call.
    ///
    /// `POST /conversations/messages/outbound`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn add_an_external_outbound_call(
        &self,
        body: &models::ProcessOutboundMessageBodyDto,
    ) -> Result<models::ProcessMessageResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/outbound",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Send a review reply to Google My Business
    ///
    /// Post a reply to a customer review on Google My Business This endpoint is
    /// internal-only and is not supported for OAuth or public API integrations. It will be
    /// removed from the public OpenAPI specification in a future release.
    ///
    /// `POST /conversations/messages/review-reply`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn send_a_review_reply_to_google_my_business(
        &self,
        body: &models::SendReviewReplyDto,
    ) -> Result<models::SendMessageResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/review-reply",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Upload file attachments
    ///
    /// Post the necessary fields for the API to upload files. The files need to be a buffer
    /// with the key "fileAttachment". The allowed file types are: JPG JPEG PNG MP4 MPEG ZIP
    /// RAR PDF DOC DOCX TXT MP3 WAV The API will return an object with the URLs
    ///
    /// `POST /conversations/messages/upload`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn upload_file_attachments(
        &self,
        body: &serde_json::Value,
    ) -> Result<models::UploadFilesResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/upload",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Complete file upload
    ///
    /// Validates the uploaded file in GCS and returns the public URL. Call this endpoint
    /// after successfully uploading the file to the signed URL. This endpoint is
    /// internal-only and is not supported for OAuth or public API integrations. It will be
    /// removed from the public OpenAPI specification in a future release.
    ///
    /// `POST /conversations/messages/upload/complete`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn complete_file_upload(
        &self,
        body: &models::CompleteFileUploadDto,
    ) -> Result<models::CompleteFileUploadResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/upload/complete",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Initiate file upload to GCS
    ///
    /// Generates a signed URL for direct file upload to Google Cloud Storage. Returns a
    /// signed URL valid for 15 minutes. Upload file via PUT request, then call /complete to
    /// finalize. This endpoint is internal-only and is not supported for OAuth or public
    /// API integrations. It will be removed from the public OpenAPI specification in a
    /// future release.
    ///
    /// `POST /conversations/messages/upload/initiate`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn initiate_file_upload_to_gcs(
        &self,
        body: &models::InitiateFileUploadDto,
    ) -> Result<models::InitiateFileUploadResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/messages/upload/initiate",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Get message by message id
    ///
    /// Get message by message id.
    ///
    /// `GET /conversations/messages/{id}`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn get_message_by_message_id(
        &self,
        id: &str,
    ) -> Result<models::GetMessageResponseDto> {
        let path = format!("/conversations/messages/{}", crate::services::encode(id));
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Add message attachments
    ///
    /// Set attachments on an existing message (replaces existing). Maximum 5 URLs.
    /// Supported for TYPE_CUSTOM_CALL (34) and TYPE_CALL (1) with subType EXTERNAL_CALL.
    ///
    /// `PUT /conversations/messages/{messageId}/attachments`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn add_message_attachments(
        &self,
        message_id: &str,
        body: &models::AddMessageAttachmentsDto,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/conversations/messages/{}/attachments",
            crate::services::encode(message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Get Recording by Message ID
    ///
    /// Get the recording for a message by passing the message id
    ///
    /// `GET /conversations/messages/{messageId}/locations/{locationId}/recording`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn get_recording_by_message_id(
        &self,
        message_id: &str,
        location_id: &str,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/conversations/messages/{}/locations/{}/recording",
            crate::services::encode(message_id),
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Cancel a scheduled message.
    ///
    /// Post the messageId for the API to delete a scheduled message.
    ///
    /// `DELETE /conversations/messages/{messageId}/schedule`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn cancel_a_scheduled_message(
        &self,
        message_id: &str,
    ) -> Result<models::CancelScheduledResponseDto> {
        let path = format!(
            "/conversations/messages/{}/schedule",
            crate::services::encode(message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Update message status
    ///
    /// Post the necessary fields for the API to update message status.
    ///
    /// `PUT /conversations/messages/{messageId}/status`
    ///
    /// Requires scope: `conversations/message.write`.
    pub async fn update_message_status(
        &self,
        message_id: &str,
        body: &models::UpdateMessageStatusDto,
    ) -> Result<models::SendMessageResponseDto> {
        let path = format!(
            "/conversations/messages/{}/status",
            crate::services::encode(message_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Agent/Ai-Bot is typing a message indicator for live chat
    ///
    /// Agent/AI-Bot will call this when they are typing a message in live chat message
    ///
    /// `POST /conversations/providers/live-chat/typing`
    ///
    /// Requires scope: `conversations/livechat.write`.
    pub async fn agent_ai_bot_is_typing_a_message_indicator_for_live_chat(
        &self,
        body: &models::UserTypingBody,
    ) -> Result<models::CreateLiveChatMessageFeedbackResponse> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/conversations/providers/live-chat/typing",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Search Conversations
    ///
    /// Returns a list of all conversations matching the search criteria along with the sort
    /// and filter options selected.
    ///
    /// `GET /conversations/search`
    ///
    /// Requires scope: `conversations.readonly`.
    pub async fn search_conversations(
        &self,
        params: &SearchConversationsParams,
    ) -> Result<models::SendConversationResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/conversations/search",
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Delete Conversation
    ///
    /// Delete the conversation details based on the conversation ID
    ///
    /// `DELETE /conversations/{conversationId}`
    ///
    /// Requires scope: `conversations.write`.
    pub async fn delete_conversation(
        &self,
        conversation_id: &str,
    ) -> Result<models::DeleteConversationSuccessfulResponse> {
        let path = format!(
            "/conversations/{}",
            crate::services::encode(conversation_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get Conversation
    ///
    /// Get the conversation details based on the conversation ID
    ///
    /// `GET /conversations/{conversationId}`
    ///
    /// Requires scope: `conversations.readonly`.
    pub async fn get_conversation(
        &self,
        conversation_id: &str,
    ) -> Result<models::GetConversationByIdResponse> {
        let path = format!(
            "/conversations/{}",
            crate::services::encode(conversation_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Update Conversation
    ///
    /// Update the conversation details based on the conversation ID
    ///
    /// `PUT /conversations/{conversationId}`
    ///
    /// Requires scope: `conversations.write`.
    pub async fn update_conversation(
        &self,
        conversation_id: &str,
        body: &models::UpdateConversationDto,
    ) -> Result<models::GetConversationSuccessfulResponse> {
        let path = format!(
            "/conversations/{}",
            crate::services::encode(conversation_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Get messages by conversation id
    ///
    /// Get messages by conversation id.
    ///
    /// `GET /conversations/{conversationId}/messages`
    ///
    /// Requires scope: `conversations/message.readonly`.
    pub async fn get_messages_by_conversation_id(
        &self,
        conversation_id: &str,
        params: &GetMessagesByConversationIdParams,
    ) -> Result<models::GetMessagesByConversationResponseDto> {
        let path = format!(
            "/conversations/{}/messages",
            crate::services::encode(conversation_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }
}