scrapebadger 0.2.0

// @generated by `cargo run -p xtask -- gen` from specs/reddit.json — do not edit by hand.
#![allow(clippy::all)]
#![allow(
    dead_code,
    unused_imports,
    unused_variables,
    non_snake_case,
    rustdoc::all
)]

use crate::core::{Client, Error, Method, QueryParams, Result};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;

/// Handle for the `reddit` platform. Obtain via [`crate::ScrapeBadger::reddit`].
#[derive(Clone)]
pub struct Reddit {
    client: Client,
}

impl Reddit {
    pub(crate) fn new(client: Client) -> Self {
        Self { client }
    }

    /// Access the underlying transport client.
    pub fn client(&self) -> &Client {
        &self.client
    }

    /// Get posts by domain
    ///
    /// Get Reddit posts linking to a specific domain.
    /// `GET /v1/reddit/domains/{domain}/posts`
    pub async fn get_domain_posts(
        &self,
        domain: impl AsRef<str>,
        params: GetDomainPostsParams,
    ) -> Result<crate::reddit::models::PostsResponse> {
        let path = format!(
            "/v1/reddit/domains/{domain}/posts",
            domain = domain.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get trending posts
    ///
    /// Get trending posts from Reddit's front page.
    /// `GET /v1/reddit/posts/trending`
    pub async fn get_trending_posts(
        &self,
        params: GetTrendingPostsParams,
    ) -> Result<crate::reddit::models::PostsResponse> {
        let path = "/v1/reddit/posts/trending".to_string();
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get post detail
    ///
    /// Get detailed information about a Reddit post.
    /// `GET /v1/reddit/posts/{post_id}`
    pub async fn get_post(
        &self,
        post_id: impl AsRef<str>,
        params: GetPostParams,
    ) -> Result<crate::reddit::models::PostResponse> {
        let path = format!("/v1/reddit/posts/{post_id}", post_id = post_id.as_ref());
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get post comments
    ///
    /// Get comment tree for a Reddit post.
    /// `GET /v1/reddit/posts/{post_id}/comments`
    pub async fn get_post_comments(
        &self,
        post_id: impl AsRef<str>,
        params: GetPostCommentsParams,
    ) -> Result<crate::reddit::models::PostCommentsResponse> {
        let path = format!(
            "/v1/reddit/posts/{post_id}/comments",
            post_id = post_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("depth", params.depth.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get cross-posts
    ///
    /// Get cross-posts and duplicates of a Reddit post.
    /// `GET /v1/reddit/posts/{post_id}/duplicates`
    pub async fn get_post_duplicates(
        &self,
        post_id: impl AsRef<str>,
        params: GetPostDuplicatesParams,
    ) -> Result<crate::reddit::models::PostDuplicatesResponse> {
        let path = format!(
            "/v1/reddit/posts/{post_id}/duplicates",
            post_id = post_id.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search Reddit posts
    ///
    /// Search Reddit posts globally or within a subreddit.
    /// `GET /v1/reddit/search/posts`
    pub async fn search_posts(
        &self,
        params: SearchPostsParams,
    ) -> Result<crate::reddit::models::PostsResponse> {
        let path = "/v1/reddit/search/posts".to_string();
        let mut q = QueryParams::new();
        q.opt("q", params.q.as_ref());
        q.opt("subreddit", params.subreddit.as_ref());
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search subreddits
    ///
    /// Search for subreddits by keyword.
    /// `GET /v1/reddit/search/subreddits`
    pub async fn search_subreddits(
        &self,
        params: SearchSubredditsParams,
    ) -> Result<crate::reddit::models::SubredditsResponse> {
        let path = "/v1/reddit/search/subreddits".to_string();
        let mut q = QueryParams::new();
        q.opt("q", params.q.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Search users
    ///
    /// Search for Reddit users.
    /// `GET /v1/reddit/search/users`
    pub async fn search_users(
        &self,
        params: SearchUsersParams,
    ) -> Result<crate::reddit::models::UsersResponse> {
        let path = "/v1/reddit/search/users".to_string();
        let mut q = QueryParams::new();
        q.opt("q", params.q.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// New subreddits
    ///
    /// Get recently created subreddits.
    /// `GET /v1/reddit/subreddits/new`
    pub async fn get_new_subreddits(
        &self,
        params: GetNewSubredditsParams,
    ) -> Result<crate::reddit::models::SubredditsResponse> {
        let path = "/v1/reddit/subreddits/new".to_string();
        let mut q = QueryParams::new();
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Popular subreddits
    ///
    /// Get popular subreddits by subscriber count.
    /// `GET /v1/reddit/subreddits/popular`
    pub async fn get_popular_subreddits(
        &self,
        params: GetPopularSubredditsParams,
    ) -> Result<crate::reddit::models::SubredditsResponse> {
        let path = "/v1/reddit/subreddits/popular".to_string();
        let mut q = QueryParams::new();
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get subreddit info
    ///
    /// Get detailed information about a subreddit.
    /// `GET /v1/reddit/subreddits/{subreddit}`
    pub async fn get_subreddit(
        &self,
        subreddit: impl AsRef<str>,
        params: GetSubredditParams,
    ) -> Result<crate::reddit::models::SubredditResponse> {
        let path = format!(
            "/v1/reddit/subreddits/{subreddit}",
            subreddit = subreddit.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get subreddit posts
    ///
    /// Get posts from a subreddit with sorting options.
    /// `GET /v1/reddit/subreddits/{subreddit}/posts`
    pub async fn get_subreddit_posts(
        &self,
        subreddit: impl AsRef<str>,
        params: GetSubredditPostsParams,
    ) -> Result<crate::reddit::models::PostsResponse> {
        let path = format!(
            "/v1/reddit/subreddits/{subreddit}/posts",
            subreddit = subreddit.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get subreddit rules
    ///
    /// Get the rules of a subreddit.
    /// `GET /v1/reddit/subreddits/{subreddit}/rules`
    pub async fn get_subreddit_rules(
        &self,
        subreddit: impl AsRef<str>,
        params: GetSubredditRulesParams,
    ) -> Result<crate::reddit::models::SubredditRulesResponse> {
        let path = format!(
            "/v1/reddit/subreddits/{subreddit}/rules",
            subreddit = subreddit.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// List wiki pages
    ///
    /// List all wiki pages in a subreddit.
    /// `GET /v1/reddit/subreddits/{subreddit}/wiki`
    pub async fn get_wiki_pages(
        &self,
        subreddit: impl AsRef<str>,
        params: GetWikiPagesParams,
    ) -> Result<crate::reddit::models::WikiPagesResponse> {
        let path = format!(
            "/v1/reddit/subreddits/{subreddit}/wiki",
            subreddit = subreddit.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get wiki page content
    ///
    /// Get the content of a specific wiki page.
    /// `GET /v1/reddit/subreddits/{subreddit}/wiki/{page}`
    pub async fn get_wiki_page(
        &self,
        subreddit: impl AsRef<str>,
        page: impl AsRef<str>,
        params: GetWikiPageParams,
    ) -> Result<crate::reddit::models::WikiPageResponse> {
        let path = format!(
            "/v1/reddit/subreddits/{subreddit}/wiki/{page}",
            subreddit = subreddit.as_ref(),
            page = page.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user profile
    ///
    /// Get a Reddit user's profile.
    /// `GET /v1/reddit/users/{username}`
    pub async fn get_user(
        &self,
        username: impl AsRef<str>,
        params: GetUserParams,
    ) -> Result<crate::reddit::models::UserResponse> {
        let path = format!("/v1/reddit/users/{username}", username = username.as_ref());
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user's comments
    ///
    /// Get comments by a Reddit user.
    /// `GET /v1/reddit/users/{username}/comments`
    pub async fn get_user_comments(
        &self,
        username: impl AsRef<str>,
        params: GetUserCommentsParams,
    ) -> Result<crate::reddit::models::UserCommentsResponse> {
        let path = format!(
            "/v1/reddit/users/{username}/comments",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user's moderated subreddits
    ///
    /// Get subreddits moderated by a user.
    /// `GET /v1/reddit/users/{username}/moderated`
    pub async fn get_user_moderated(
        &self,
        username: impl AsRef<str>,
        params: GetUserModeratedParams,
    ) -> Result<crate::reddit::models::UserModeratedResponse> {
        let path = format!(
            "/v1/reddit/users/{username}/moderated",
            username = username.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user's posts
    ///
    /// Get posts submitted by a Reddit user.
    /// `GET /v1/reddit/users/{username}/posts`
    pub async fn get_user_posts(
        &self,
        username: impl AsRef<str>,
        params: GetUserPostsParams,
    ) -> Result<crate::reddit::models::PostsResponse> {
        let path = format!(
            "/v1/reddit/users/{username}/posts",
            username = username.as_ref()
        );
        let mut q = QueryParams::new();
        q.opt("sort", params.sort.as_ref());
        q.opt("t", params.t.as_ref());
        q.opt("limit", params.limit.as_ref());
        q.opt("after", params.after.as_ref());
        let query = q.into_pairs();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }

    /// Get user's trophies
    ///
    /// Get a user's trophy case.
    /// `GET /v1/reddit/users/{username}/trophies`
    pub async fn get_user_trophies(
        &self,
        username: impl AsRef<str>,
        params: GetUserTrophiesParams,
    ) -> Result<crate::reddit::models::UserTrophiesResponse> {
        let path = format!(
            "/v1/reddit/users/{username}/trophies",
            username = username.as_ref()
        );
        let query: Vec<(String, String)> = Vec::new();
        let body = None;
        self.client.send(Method::GET, &path, &query, body).await
    }
}

// ===== Models =====

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct HttpValidationError {
    pub detail: Vec<ValidationError>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct ValidationError {
    pub ctx: HashMap<String, Value>,
    pub input: Option<Value>,
    pub loc: Vec<Value>,
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub msg: Option<String>,
    #[serde(rename = "type")]
    #[serde(default, deserialize_with = "crate::core::flex::opt_string")]
    pub type_: Option<String>,
    /// Fields present in the response but not in the spec.
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

/// Parameters for [`GetDomainPostsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetDomainPostsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetTrendingPostsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetTrendingPostsParams {
    /// Sort: hot, new, top, rising, controversial, best
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    /// Time filter
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetPostParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetPostParams {}

/// Parameters for [`GetPostCommentsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetPostCommentsParams {
    /// Sort: confidence, top, new, controversial, old, qa
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<i64>,
}

/// Parameters for [`GetPostDuplicatesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetPostDuplicatesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`SearchPostsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchPostsParams {
    /// Search query
    #[serde(skip_serializing_if = "Option::is_none")]
    pub q: Option<String>,
    /// Restrict to subreddit
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subreddit: Option<String>,
    /// Sort: relevance, hot, top, new, comments
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    /// Time: hour, day, week, month, year, all
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`SearchSubredditsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchSubredditsParams {
    /// Search query
    #[serde(skip_serializing_if = "Option::is_none")]
    pub q: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`SearchUsersParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchUsersParams {
    /// Search query
    #[serde(skip_serializing_if = "Option::is_none")]
    pub q: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetNewSubredditsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetNewSubredditsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetPopularSubredditsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetPopularSubredditsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetSubredditParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetSubredditParams {}

/// Parameters for [`GetSubredditPostsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetSubredditPostsParams {
    /// Sort: hot, new, top, rising, controversial
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    /// Time filter
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetSubredditRulesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetSubredditRulesParams {}

/// Parameters for [`GetWikiPagesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetWikiPagesParams {}

/// Parameters for [`GetWikiPageParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetWikiPageParams {}

/// Parameters for [`GetUserParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserParams {}

/// Parameters for [`GetUserCommentsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserCommentsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetUserModeratedParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserModeratedParams {}

/// Parameters for [`GetUserPostsParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserPostsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub t: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
}

/// Parameters for [`GetUserTrophiesParams`]. All fields optional; required ones are noted per method.
#[derive(Debug, Clone, Default, Serialize)]
pub struct GetUserTrophiesParams {}