ghl-sdk 0.5.2

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

#![allow(clippy::too_many_arguments)]

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

/// Typed access to the `social-planner` API v3 surface (45 operations). Obtained via
/// [`Ghl::v3`](crate::Ghl::v3)`().social_planner()`.
#[derive(Debug, Clone)]
pub struct SocialPlannerService {
    pub(crate) client: Ghl,
}

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

/// Query parameters for
/// [`SocialPlannerService::get_all_categories_with_their_queue_status`].
#[derive(Debug, Clone, Default)]
pub struct GetAllCategoriesWithTheirQueueStatusParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
    /// Number of items to skip
    pub skip: Option<String>,
    /// Maximum number of items to return
    pub limit: Option<String>,
    /// Search query
    pub q: Option<String>,
}

impl GetAllCategoriesWithTheirQueueStatusParams {
    /// 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 items to skip
    pub fn skip(mut self, v: impl Into<String>) -> Self {
        self.skip = Some(v.into());
        self
    }

    /// Maximum number of items to return
    pub fn limit(mut self, v: impl Into<String>) -> Self {
        self.limit = Some(v.into());
        self
    }

    /// Search query
    pub fn q(mut self, v: impl Into<String>) -> Self {
        self.q = 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.skip {
            q.push(("skip".into(), v.to_string()));
        }
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.q {
            q.push(("q".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for
/// [`SocialPlannerService::delete_an_active_post_and_schedule_the_next_one`].
#[derive(Debug, Clone, Default)]
pub struct DeleteAnActivePostAndScheduleTheNextOneParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::fetch_a_category_queue_by_id`].
#[derive(Debug, Clone, Default)]
pub struct FetchACategoryQueueByIdParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::delete_an_item_from_a_queue`].
#[derive(Debug, Clone, Default)]
pub struct DeleteAnItemFromAQueueParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
    /// Edit session ID
    pub session_id: Option<String>,
}

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

    /// Edit session ID
    pub fn session_id(mut self, v: impl Into<String>) -> Self {
        self.session_id = 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.session_id {
            q.push(("sessionId".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`SocialPlannerService::create_a_comment_or_reply`].
#[derive(Debug, Clone, Default)]
pub struct CreateACommentOrReplyParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::list_comments_for_a_post_or_thread`].
#[derive(Debug, Clone, Default)]
pub struct ListCommentsForAPostOrThreadParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::unlike_a_comment`].
#[derive(Debug, Clone, Default)]
pub struct UnlikeACommentParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::like_a_comment`].
#[derive(Debug, Clone, Default)]
pub struct LikeACommentParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::get_available_accounts_step_2_of_3`].
#[derive(Debug, Clone, Default)]
pub struct GetAvailableAccountsStep2Of3Params {
    /// Search term to filter accounts/pages by name. Useful when the user has many pages to
    /// choose from.
    pub search: Option<String>,
}

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

    /// Search term to filter accounts/pages by name. Useful when the user has many pages to
    /// choose from.
    pub fn search(mut self, v: impl Into<String>) -> Self {
        self.search = Some(v.into());
        self
    }

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

/// Query parameters for [`SocialPlannerService::start_o_auth_flow_step_1_of_3`].
#[derive(Debug, Clone, Default)]
pub struct StartOAuthFlowStep1Of3Params {
    /// Location Id
    /// Required by the API.
    pub location_id: String,
    /// User Id
    /// Required by the API.
    pub user_id: String,
    /// Page
    pub page: Option<String>,
    /// Reconnect
    pub reconnect: Option<String>,
}

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

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

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

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("locationId".into(), self.location_id.clone()),
            ("userId".into(), self.user_id.clone()),
        ];
        if let Some(v) = &self.page {
            q.push(("page".into(), v.to_string()));
        }
        if let Some(v) = &self.reconnect {
            q.push(("reconnect".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`SocialPlannerService::get_social_media_statistics`].
#[derive(Debug, Clone, Default)]
pub struct GetSocialMediaStatisticsParams {
    /// Location ID
    /// Required by the API.
    pub location_id: String,
}

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

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`SocialPlannerService::delete_account`].
#[derive(Debug, Clone, Default)]
pub struct DeleteAccountParams {
    /// Company ID
    pub company_id: Option<String>,
    /// User ID
    pub user_id: Option<String>,
}

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

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

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

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = Vec::new();
        if let Some(v) = &self.company_id {
            q.push(("companyId".into(), v.to_string()));
        }
        if let Some(v) = &self.user_id {
            q.push(("userId".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`SocialPlannerService::get_categories_by_location_id`].
#[derive(Debug, Clone, Default)]
pub struct GetCategoriesByLocationIdParams {
    /// Search text string
    pub search_text: Option<String>,
    /// Limit
    pub limit: Option<String>,
    /// Skip
    pub skip: Option<String>,
}

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

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

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

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

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

/// Query parameters for [`SocialPlannerService::get_upload_status`].
#[derive(Debug, Clone, Default)]
pub struct GetUploadStatusParams {
    /// Number of records to skip
    pub skip: Option<String>,
    /// Maximum number of records to return
    pub limit: Option<String>,
    /// Include user data in response
    pub include_users: Option<String>,
    /// Filter CSVs imported from template library
    pub is_from_template: Option<String>,
    /// User ID
    /// Required by the API.
    pub user_id: String,
}

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

    /// Number of records to skip
    pub fn skip(mut self, v: impl Into<String>) -> Self {
        self.skip = Some(v.into());
        self
    }

    /// Maximum number of records to return
    pub fn limit(mut self, v: impl Into<String>) -> Self {
        self.limit = Some(v.into());
        self
    }

    /// Include user data in response
    pub fn include_users(mut self, v: impl Into<String>) -> Self {
        self.include_users = Some(v.into());
        self
    }

    /// Filter CSVs imported from template library
    pub fn is_from_template(mut self, v: impl Into<String>) -> Self {
        self.is_from_template = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("userId".into(), self.user_id.clone())];
        if let Some(v) = &self.skip {
            q.push(("skip".into(), v.to_string()));
        }
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.include_users {
            q.push(("includeUsers".into(), v.to_string()));
        }
        if let Some(v) = &self.is_from_template {
            q.push(("isFromTemplate".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`SocialPlannerService::get_csv_post`].
#[derive(Debug, Clone, Default)]
pub struct GetCsvPostParams {
    /// Number of records to skip
    pub skip: Option<String>,
    /// Maximum number of records to return
    pub limit: Option<String>,
}

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

    /// Number of records to skip
    pub fn skip(mut self, v: impl Into<String>) -> Self {
        self.skip = Some(v.into());
        self
    }

    /// Maximum number of records to return
    pub fn limit(mut self, v: impl Into<String>) -> Self {
        self.limit = Some(v.into());
        self
    }

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

/// Query parameters for [`SocialPlannerService::get_tags_by_location_id`].
#[derive(Debug, Clone, Default)]
pub struct GetTagsByLocationIdParams {
    /// Search text string
    pub search_text: Option<String>,
    /// Limit
    pub limit: Option<String>,
    /// Skip
    pub skip: Option<String>,
}

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

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

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

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

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

impl SocialPlannerService {
    /// Create a new category queue
    ///
    /// Creates a queue in draft status for a category. Published posts are auto-added. Use
    /// update endpoint to activate.
    ///
    /// `POST /social-media-posting/category/queues`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn create_a_new_category_queue(
        &self,
        body: &models::CreateCategoryQueueDTO,
    ) -> Result<models::WrappedCreateCategoryQueueResponseDTO> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/social-media-posting/category/queues",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Get all categories with their queue status
    ///
    /// Returns categories with status: "available" (no queue), "in_queue" (active/paused
    /// queue), or "draft" (queue in draft).
    ///
    /// `GET /social-media-posting/category/queues/available-categories`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn get_all_categories_with_their_queue_status(
        &self,
        params: &GetAllCategoriesWithTheirQueueStatusParams,
    ) -> Result<models::WrappedFetchAvailableCategoriesResponseDTO> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/social-media-posting/category/queues/available-categories",
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Fetch category queues for a location
    ///
    /// Retrieves a paginated list of all category queues for a given location, excluding
    /// any that have been marked as deleted.
    ///
    /// `POST /social-media-posting/category/queues/list`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn fetch_category_queues_for_a_location(
        &self,
        body: &models::FetchCategoryQueuesDTO,
    ) -> Result<models::WrappedFetchCategoryQueuesResponseDTO> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/social-media-posting/category/queues/list",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Get scheduled posts calendar view
    ///
    /// Returns scheduled posts from active queues within a date range. Supports filtering
    /// by categories and accounts.
    ///
    /// `POST /social-media-posting/category/queues/list/calendar`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn get_scheduled_posts_calendar_view(
        &self,
        body: &models::CalendarListDTO,
    ) -> Result<models::WrappedFetchCalendarListResponseDTO> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/social-media-posting/category/queues/list/calendar",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Delete an active post and schedule the next one
    ///
    /// Deletes a post that is currently scheduled and automatically triggers the scheduling
    /// of the next available post in the queue.
    ///
    /// `DELETE /social-media-posting/category/queues/{postId}/active-post`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn delete_an_active_post_and_schedule_the_next_one(
        &self,
        post_id: &str,
        params: &DeleteAnActivePostAndScheduleTheNextOneParams,
    ) -> Result<models::WrappedDeleteActivePostResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/active-post",
            crate::services::encode(post_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Fetch a category queue by ID
    ///
    /// Retrieves the details of a single category queue by its unique ID. The response
    /// includes a count of posts within the queue that have errors.
    ///
    /// `GET /social-media-posting/category/queues/{queueId}`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn fetch_a_category_queue_by_id(
        &self,
        queue_id: &str,
        params: &FetchACategoryQueueByIdParams,
    ) -> Result<models::WrappedFetchQueueByIdResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}",
            crate::services::encode(queue_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Update queue settings or status
    ///
    /// Updates queue status (active/paused/deleted), time slots, or skip dates.
    ///
    /// `PUT /social-media-posting/category/queues/{queueId}`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn update_queue_settings_or_status(
        &self,
        queue_id: &str,
        body: &models::UpdateCategoryQueueDTO,
    ) -> Result<models::WrappedUpdateCategoryQueueResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Create a new item in the queue
    ///
    /// Adds a new post item to a queue. Use sessionId for edit session or directToQueue for
    /// immediate addition.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/create/item`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn create_a_new_item_in_the_queue(
        &self,
        queue_id: &str,
        body: &models::CreateQueueItemDTO,
    ) -> Result<models::WrappedCreateQueueItemResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/create/item",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Fetch calendar view for an edit session
    ///
    /// Retrieves a calendar preview of scheduled posts based on draft items within an edit
    /// session. This shows how posts would be scheduled if changes were saved.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/edit/calendar`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn fetch_calendar_view_for_an_edit_session(
        &self,
        queue_id: &str,
        body: &models::EditSessionCalendarDTO,
    ) -> Result<models::WrappedEditSessionCalendarResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/edit/calendar",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Discard edit session changes
    ///
    /// Cancels the edit session and deletes all staged changes without affecting the live
    /// queue.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/edit/discard`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn discard_edit_session_changes(
        &self,
        queue_id: &str,
        body: &models::DiscardEditSessionDTO,
    ) -> Result<models::WrappedDiscardEditSessionResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/edit/discard",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Save edit session changes
    ///
    /// Applies all staged changes to the live queue and closes the edit session.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/edit/save`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn save_edit_session_changes(
        &self,
        queue_id: &str,
        body: &models::SaveEditSessionDTO,
    ) -> Result<models::WrappedSaveEditSessionResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/edit/save",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Start or resume an edit session
    ///
    /// Creates a draft copy of queue items for editing. Changes are staged until saved or
    /// discarded.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/edit/start`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn start_or_resume_an_edit_session(
        &self,
        queue_id: &str,
        body: &models::StartEditSessionDTO,
    ) -> Result<models::WrappedStartEditSessionResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/edit/start",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Fetch items from a queue
    ///
    /// Returns paginated queue items. Pass sessionId to get draft items from an edit
    /// session instead of live items.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/items`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn fetch_items_from_a_queue(
        &self,
        queue_id: &str,
        body: &models::FetchQueueItemsDTO,
    ) -> Result<models::WrappedFetchQueueItemsResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/items",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Delete an item from a queue
    ///
    /// Deletes an item from a specific category queue.
    ///
    /// `DELETE /social-media-posting/category/queues/{queueId}/items/{itemId}`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn delete_an_item_from_a_queue(
        &self,
        queue_id: &str,
        item_id: &str,
        params: &DeleteAnItemFromAQueueParams,
    ) -> Result<models::WrappedGeneralSuccessResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/items/{}",
            crate::services::encode(queue_id),
            crate::services::encode(item_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Update an item in a queue
    ///
    /// Updates the content or variations of a specific item within a category queue.
    ///
    /// `PUT /social-media-posting/category/queues/{queueId}/items/{itemId}`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn update_an_item_in_a_queue(
        &self,
        queue_id: &str,
        item_id: &str,
        body: &models::UpdateQueueItemDTO,
    ) -> Result<models::WrappedUpdateQueueItemResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/items/{}",
            crate::services::encode(queue_id),
            crate::services::encode(item_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Clone a queue item
    ///
    /// Duplicates an existing queue item at a specified order position. Requires an active
    /// edit session.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/items/{itemId}/clone`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn clone_a_queue_item(
        &self,
        queue_id: &str,
        item_id: &str,
        body: &models::CloneQueueItemDTO,
    ) -> Result<models::WrappedCloneQueueItemResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/items/{}/clone",
            crate::services::encode(queue_id),
            crate::services::encode(item_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Reset an item in a queue
    ///
    /// Resets a specific queue item to its original state, discarding any modifications
    /// made.
    ///
    /// `PUT /social-media-posting/category/queues/{queueId}/items/{itemId}/reset`
    ///
    /// Requires scope: `socialplanner/category.write`.
    pub async fn reset_an_item_in_a_queue(
        &self,
        queue_id: &str,
        item_id: &str,
        body: &models::ResetQueueItemDTO,
    ) -> Result<models::WrappedResetQueueItemResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/items/{}/reset",
            crate::services::encode(queue_id),
            crate::services::encode(item_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Fetch slot information for queue items
    ///
    /// Returns paginated slot information (scheduledDateTime, isSkipped) for queue items.
    /// Pass sessionId to get slots for draft items, or omit for live items. Call this after
    /// mutations to refresh slot data.
    ///
    /// `POST /social-media-posting/category/queues/{queueId}/slots`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn fetch_slot_information_for_queue_items(
        &self,
        queue_id: &str,
        body: &models::FetchSlotsDTO,
    ) -> Result<models::WrappedFetchSlotsResponseDTO> {
        let path = format!(
            "/social-media-posting/category/queues/{}/slots",
            crate::services::encode(queue_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Create a comment or reply
    ///
    /// Create a top-level comment on a post (`isParentThread: true`, `parentId` = postId)
    /// or a reply to an existing comment (`isParentThread: false`, `parentId` = commentId).
    /// Per-platform content max length: Facebook 8000, Instagram 2200, Linkedin 3000,
    /// Community 8000, Tiktok 150, Bluesky 300, Youtube 10000, Threads 500.
    /// **Optional-field platform support:** - `attachments` — supported on **Facebook
    /// only**. Ignored on Instagram, LinkedIn, TikTok, Bluesky, Community (Community
    /// processes the field but external URLs are not rendered due to its bucket
    /// restriction). - `mentions` — supported on **Facebook**
    ///
    /// `POST /social-media-posting/comments/{platform}`
    pub async fn create_a_comment_or_reply(
        &self,
        platform: &str,
        params: &CreateACommentOrReplyParams,
        body: &models::CommentsCreateBodyDTO,
    ) -> Result<models::CommentsCreateResponseDTO> {
        let path = format!(
            "/social-media-posting/comments/{}",
            crate::services::encode(platform)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// List comments for a post or thread
    ///
    /// Paginated list of comments scoped to a post (`parentId` = postId) or a comment
    /// thread (`parentId` = commentId). Use `skip`/`limit` for pagination, `sortBy` for
    /// ordering, `originIds` to filter by connected account, and `search` for keyword
    /// search.
    ///
    /// `POST /social-media-posting/comments/{platform}/list`
    pub async fn list_comments_for_a_post_or_thread(
        &self,
        platform: &str,
        params: &ListCommentsForAPostOrThreadParams,
        body: &models::CommentsGetListBodyDTO,
    ) -> Result<models::CommentsGetListResponseDTO> {
        let path = format!(
            "/social-media-posting/comments/{}/list",
            crate::services::encode(platform)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Unlike a comment
    ///
    /// Remove a like from a comment by its **Highlevel** comment ID (the `_id` returned by
    /// the list-comments endpoint — not the native platform ID). Works for any comment
    /// level — top-level comments, replies, and replies-to-replies. **Supported
    /// platforms:** Facebook, LinkedIn, Community, TikTok, Bluesky. Instagram is not
    /// supported (passing `instagram` returns 400).
    ///
    /// `DELETE /social-media-posting/comments/{platform}/{id}/like`
    pub async fn unlike_a_comment(
        &self,
        platform: &str,
        id: &str,
        params: &UnlikeACommentParams,
    ) -> Result<models::DeleteLikeResponseDTO> {
        let path = format!(
            "/social-media-posting/comments/{}/{}/like",
            crate::services::encode(platform),
            crate::services::encode(id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Like a comment
    ///
    /// Like a comment by its **Highlevel** comment ID (the `_id` returned by the
    /// list-comments endpoint — not the native platform ID). Works for any comment level —
    /// top-level comments, replies, and replies-to-replies. **Supported platforms:**
    /// Facebook, LinkedIn, Community, TikTok, Bluesky. Instagram is not supported (passing
    /// `instagram` returns 400).
    ///
    /// `POST /social-media-posting/comments/{platform}/{id}/like`
    pub async fn like_a_comment(
        &self,
        platform: &str,
        id: &str,
        params: &LikeACommentParams,
    ) -> Result<models::CommentsLikeResponseDTO> {
        let path = format!(
            "/social-media-posting/comments/{}/{}/like",
            crate::services::encode(platform),
            crate::services::encode(id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get Available Accounts (Step 2 of 3)
    ///
    /// ## OAuth Connection Flow - Step 2: Get Available Accounts After completing OAuth
    /// authentication (Step 1), use this endpoint to retrieve the list of available pages,
    /// channels, or locations that can be connected. ### OAuth Flow Position 1. **Start
    /// OAuth** → User authenticates, returns `accountId` 2. **Get Accounts** (this
    /// endpoint) → Lists available pages/channels to connect 3. **Attach Account** →
    /// Connect the selected account ### What This Returns The response varies by platform:
    /// | Platform | Returns | |----------|--------| | **facebook** | List of Facebook Pages
    /// the user manages | | **instagra
    ///
    /// `GET /social-media-posting/oauth/{locationId}/{platform}/accounts/{accountId}`
    pub async fn get_available_accounts_step_2_of_3(
        &self,
        location_id: &str,
        platform: &str,
        account_id: &str,
        params: &GetAvailableAccountsStep2Of3Params,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/social-media-posting/oauth/{}/{}/accounts/{}",
            crate::services::encode(location_id),
            crate::services::encode(platform),
            crate::services::encode(account_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Connect Account (Step 3 of 3)
    ///
    /// ## OAuth Connection Flow - Step 3: Connect the Account This is the final step in the
    /// OAuth flow. After retrieving available accounts (Step 2), use this endpoint to
    /// connect the selected account to your location. ### OAuth Flow Summary 1. **Start
    /// OAuth** → User authenticates with platform 2. **Get Accounts** → Retrieved available
    /// pages/channels 3. **Attach Account** (this endpoint) → Connect the selected account
    /// ### Request Body by Platform The request body structure varies depending on the
    /// platform: #### Facebook / Instagram ```json { "type": "page", "originId":
    /// "244405XXXXX11687", "name": "My
    ///
    /// `POST /social-media-posting/oauth/{locationId}/{platform}/accounts/{accountId}`
    pub async fn connect_account_step_3_of_3(
        &self,
        location_id: &str,
        platform: &str,
        account_id: &str,
        body: &serde_json::Value,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/social-media-posting/oauth/{}/{}/accounts/{}",
            crate::services::encode(location_id),
            crate::services::encode(platform),
            crate::services::encode(account_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Start OAuth Flow (Step 1 of 3)
    ///
    /// ## OAuth Connection Flow - Step 1: Initiate OAuth This is the first step in the
    /// 3-step OAuth flow to connect a social media account: 1. **Start OAuth** (this
    /// endpoint) → User authenticates with the platform 2. **Get Accounts** → Retrieve
    /// available pages/channels to connect 3. **Attach Account** → Connect the selected
    /// account to your location ### How to Use Open this API in a browser window (not via
    /// cURL) with the required query parameters. The user will be redirected to the
    /// platform's OAuth login screen. ### Receiving the OAuth Response After successful
    /// authentication, the OAuth window will po
    ///
    /// `GET /social-media-posting/oauth/{platform}/start`
    pub async fn start_o_auth_flow_step_1_of_3(
        &self,
        platform: &str,
        params: &StartOAuthFlowStep1Of3Params,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/social-media-posting/oauth/{}/start",
            crate::services::encode(platform)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Get Social Media Statistics
    ///
    /// Retrieve analytics data for multiple social media accounts. Supports custom date
    /// ranges for both the current period and a comparison period. If no date ranges are
    /// provided, defaults to the last 7 days (excluding today) with comparison to the
    /// previous 7 days.
    ///
    /// `POST /social-media-posting/statistics`
    ///
    /// Requires scope: `socialplanner/statistics.readonly`.
    pub async fn get_social_media_statistics(
        &self,
        params: &GetSocialMediaStatisticsParams,
        body: &serde_json::Value,
    ) -> Result<serde_json::Value> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/social-media-posting/statistics",
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Get Accounts
    ///
    /// Get list of accounts and groups
    ///
    /// `GET /social-media-posting/{locationId}/accounts`
    ///
    /// Requires scope: `socialplanner/account.readonly`.
    pub async fn get_accounts(&self, location_id: &str) -> Result<models::AccountsListResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/accounts",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Delete Account
    ///
    /// Delete account and account from group
    ///
    /// `DELETE /social-media-posting/{locationId}/accounts/{id}`
    pub async fn delete_account(
        &self,
        location_id: &str,
        id: &str,
        params: &DeleteAccountParams,
    ) -> Result<models::LocationAndAccountDeleteResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/accounts/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get categories by location id
    ///
    /// Retrieve all categories for a specific location with optional search and pagination
    ///
    /// `GET /social-media-posting/{locationId}/categories`
    ///
    /// Requires scope: `socialplanner/category.readonly`.
    pub async fn get_categories_by_location_id(
        &self,
        location_id: &str,
        params: &GetCategoriesByLocationIdParams,
    ) -> Result<models::GetByLocationIdResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/categories",
            crate::services::encode(location_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Get categories by id
    ///
    /// Retrieve a specific category by its ID
    ///
    /// `GET /social-media-posting/{locationId}/categories/{id}`
    pub async fn get_categories_by_id(
        &self,
        location_id: &str,
        id: &str,
    ) -> Result<models::GetByIdResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/categories/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Get Upload Status
    ///
    /// Get the status of all CSV imports for a location
    ///
    /// `GET /social-media-posting/{locationId}/csv`
    pub async fn get_upload_status(
        &self,
        location_id: &str,
        params: &GetUploadStatusParams,
    ) -> Result<models::GetUploadStatusResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv",
            crate::services::encode(location_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Upload CSV
    ///
    /// Upload a CSV file containing social media posts for bulk scheduling
    ///
    /// `POST /social-media-posting/{locationId}/csv`
    ///
    /// Requires scope: `socialplanner/csv.write`.
    pub async fn upload_csv(
        &self,
        location_id: &str,
        body: &serde_json::Value,
    ) -> Result<models::UploadFileResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Delete CSV Post
    ///
    /// Delete a specific post from a CSV import
    ///
    /// `DELETE /social-media-posting/{locationId}/csv/{csvId}/post/{postId}`
    pub async fn delete_csv_post(
        &self,
        location_id: &str,
        csv_id: &str,
        post_id: &str,
    ) -> Result<models::DeletePostResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv/{}/post/{}",
            crate::services::encode(location_id),
            crate::services::encode(csv_id),
            crate::services::encode(post_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Delete CSV
    ///
    /// Delete a CSV import and all its associated posts
    ///
    /// `DELETE /social-media-posting/{locationId}/csv/{id}`
    pub async fn delete_csv(
        &self,
        location_id: &str,
        id: &str,
    ) -> Result<models::DeleteCsvResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get CSV Post
    ///
    /// Get details of a specific CSV import including its posts
    ///
    /// `GET /social-media-posting/{locationId}/csv/{id}`
    pub async fn get_csv_post(
        &self,
        location_id: &str,
        id: &str,
        params: &GetCsvPostParams,
    ) -> Result<models::GetCsvPostResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Start CSV Finalize
    ///
    /// Finalize a CSV import and schedule all posts for publishing
    ///
    /// `PATCH /social-media-posting/{locationId}/csv/{id}`
    pub async fn start_csv_finalize(
        &self,
        location_id: &str,
        id: &str,
        body: &models::CSVDefaultDTO,
    ) -> Result<models::CsvPostStatusResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/csv/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::PATCH,
                &path,
                &query,
                Some(body),
                Some("v3"),
            )
            .await
    }

    /// Create post
    ///
    /// Create posts for all supported platforms. It is possible to create customized posts
    /// per channel by using the same platform account IDs in a request and hitting the
    /// create post API multiple times with different summaries and account IDs per
    /// platform. The content and media limitations, as well as platform rate limiters
    /// corresponding to the respective platforms, are provided in the following reference
    /// link: Link: [Platform
    /// Limitations](https://help.leadconnectorhq.com/support/solutions/articles/48001240003-social-planner-image-video-content-and-api-limitations
    /// "Social Planner Help")
    ///
    /// `POST /social-media-posting/{locationId}/posts`
    ///
    /// Requires scope: `socialplanner/post.write`.
    pub async fn create_post(
        &self,
        location_id: &str,
        body: &models::CreatePostDTO,
    ) -> Result<models::CreatePostSuccessfulResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/posts",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Bulk Delete Social Planner Posts
    ///
    /// Deletes multiple posts based on the provided list of post IDs. This operation is
    /// useful for clearing up large numbers of posts efficiently. Note: 1.The maximum
    /// number of posts that can be deleted in a single request is '50'. 2.However, It will
    /// only get deleted in CRM database but still it is recommended to be cautious of this
    /// operation.
    ///
    /// `POST /social-media-posting/{locationId}/posts/bulk-delete`
    pub async fn bulk_delete_social_planner_posts(
        &self,
        location_id: &str,
        body: &models::DeletePostsDto,
    ) -> Result<models::BulkDeleteResponseDto> {
        let path = format!(
            "/social-media-posting/{}/posts/bulk-delete",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Get posts
    ///
    /// Get Posts
    ///
    /// `POST /social-media-posting/{locationId}/posts/list`
    ///
    /// Requires scope: `socialplanner/post.readonly`.
    pub async fn get_posts(
        &self,
        location_id: &str,
        body: &models::SearchPostDTO,
    ) -> Result<models::PostSuccessfulResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/posts/list",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Delete Post
    ///
    /// `DELETE /social-media-posting/{locationId}/posts/{id}`
    pub async fn delete_post(
        &self,
        location_id: &str,
        id: &str,
    ) -> Result<models::DeletePostSuccessfulResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/posts/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("v3"),
            )
            .await
    }

    /// Get post
    ///
    /// `GET /social-media-posting/{locationId}/posts/{id}`
    pub async fn get_post(
        &self,
        location_id: &str,
        id: &str,
    ) -> Result<models::GetPostSuccessfulResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/posts/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Edit post
    ///
    /// Create posts for all supported platforms. It is possible to create customized posts
    /// per channel by using the same platform account IDs in a request and hitting the
    /// create post API multiple times with different summaries and account IDs per
    /// platform. The content and media limitations, as well as platform rate limiters
    /// corresponding to the respective platforms, are provided in the following reference
    /// link: Link: [Platform
    /// Limitations](https://help.leadconnectorhq.com/support/solutions/articles/48001240003-social-planner-image-video-content-and-api-limitations
    /// "Social Planner Help")
    ///
    /// `PUT /social-media-posting/{locationId}/posts/{id}`
    pub async fn edit_post(
        &self,
        location_id: &str,
        id: &str,
        body: &models::CreatePostDTO,
    ) -> Result<models::UpdatePostSuccessfulResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/posts/{}",
            crate::services::encode(location_id),
            crate::services::encode(id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::PUT, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Set Accounts
    ///
    /// Set social media accounts for a CSV import to publish posts to
    ///
    /// `POST /social-media-posting/{locationId}/set-accounts`
    ///
    /// Requires scope: `socialplanner/csv.write`.
    pub async fn set_accounts(
        &self,
        location_id: &str,
        body: &models::SetAccountsDTO,
    ) -> Result<models::SetAccountsResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/set-accounts",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }

    /// Get tags by location id
    ///
    /// Retrieve all tags for a specific location with optional search and pagination
    ///
    /// `GET /social-media-posting/{locationId}/tags`
    pub async fn get_tags_by_location_id(
        &self,
        location_id: &str,
        params: &GetTagsByLocationIdParams,
    ) -> Result<models::GetTagsByLocationIdResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/tags",
            crate::services::encode(location_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(reqwest::Method::GET, &path, &query, None::<&()>, Some("v3"))
            .await
    }

    /// Get tags by ids
    ///
    /// Retrieve specific tags by their IDs
    ///
    /// `POST /social-media-posting/{locationId}/tags/details`
    pub async fn get_tags_by_ids(
        &self,
        location_id: &str,
        body: &models::UpdateTagDTO,
    ) -> Result<models::GetTagsByIdResponseDTO> {
        let path = format!(
            "/social-media-posting/{}/tags/details",
            crate::services::encode(location_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(reqwest::Method::POST, &path, &query, Some(body), Some("v3"))
            .await
    }
}