reddit-insights 1.0.0

Official Rust SDK for the Reddit Insights API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Type definitions for the Reddit Insights SDK

use serde::{Deserialize, Serialize};

/// A single search result
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SearchResult {
    pub id: String,
    pub title: String,
    pub content: String,
    pub subreddit: String,
    pub upvotes: i32,
    pub comments: i32,
    pub created: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relevance: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub similarity_score: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sentiment: Option<String>,
    pub url: String,
}

/// Response from semantic search
#[derive(Debug, Clone, Deserialize)]
pub struct SemanticSearchResponse {
    pub success: bool,
    pub data: Option<SemanticSearchData>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct SemanticSearchData {
    pub query: String,
    pub results: Vec<SearchResult>,
    pub total: i32,
    pub processing_time_ms: i32,
    pub ai_summary: Option<String>,
}

/// Response from vector search
#[derive(Debug, Clone, Deserialize)]
pub struct VectorSearchResponse {
    pub success: bool,
    pub data: Option<VectorSearchData>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct VectorSearchData {
    pub query: String,
    pub results: Vec<SearchResult>,
    pub total: i32,
    pub processing_time_ms: i32,
}

/// A trending topic
#[derive(Debug, Clone, Deserialize)]
pub struct TrendTopic {
    pub id: String,
    pub topic: String,
    pub post_count: i32,
    pub total_upvotes: i32,
    pub total_comments: i32,
    pub avg_sentiment: f64,
    pub top_subreddits: Vec<String>,
    pub trending_keywords: Vec<String>,
    pub sample_posts: Vec<SamplePost>,
    pub trend_score: f64,
    pub growth_rate: f64,
}

#[derive(Debug, Clone, Deserialize)]
pub struct SamplePost {
    pub id: String,
    pub title: String,
    pub subreddit: String,
    pub upvotes: i32,
    pub comments: i32,
    pub created: String,
}

/// Response from trends endpoint
#[derive(Debug, Clone, Deserialize)]
pub struct TrendsResponse {
    pub success: bool,
    pub data: Option<TrendsData>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct TrendsData {
    pub trends: Vec<TrendTopic>,
    pub total: i32,
    pub date_range: DateRange,
    pub processing_time_ms: i32,
}

#[derive(Debug, Clone, Deserialize)]
pub struct DateRange {
    pub start: String,
    pub end: String,
}

/// A monitoring sonar
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Sonar {
    pub id: String,
    pub name: String,
    pub query: String,
    pub description: Option<String>,
    pub enabled: bool,
    pub schedule: String,
    pub last_executed_at: Option<String>,
    pub next_execution_at: Option<String>,
    pub created_at: String,
}

/// Response from list sonars endpoint
#[derive(Debug, Clone, Deserialize)]
pub struct SonarsResponse {
    pub success: bool,
    pub data: Option<SonarsData>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct SonarsData {
    pub sonars: Vec<Sonar>,
}

/// Options for creating a sonar
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateSonarOptions {
    pub name: String,
    pub query: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schedule: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub triggers: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notify_email: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notify_slack: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slack_webhook: Option<String>,
}

/// Response from create sonar endpoint
#[derive(Debug, Clone, Deserialize)]
pub struct CreateSonarResponse {
    pub success: bool,
    pub data: Option<CreateSonarData>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct CreateSonarData {
    pub sonar: Sonar,
}