1use serde::{Deserialize, Serialize};
2use std::collections::HashMap;
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
6#[serde(tag = "type", rename_all = "lowercase")]
7pub enum DocumentContent {
8    Text { text: String },
10    Auto { base64_data: String },
12}
13
14pub type Metadata = HashMap<String, MetadataValue>;
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum MetadataValue {
21    String(String),
22    Array(Vec<String>),
23}
24
25pub type Filter = HashMap<String, serde_json::Value>;
27
28#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
30#[serde(rename_all = "lowercase")]
31pub enum LatencyMode {
32    Low,
33    High,
34}
35
36#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
38#[serde(rename_all = "snake_case")]
39pub enum IndexStatus {
40    NotParsed,
41    NotIndexed,
42    Parsing,
43    ParsingFailed,
44    Indexing,
45    IndexingFailed,
46    Indexed,
47}
48
49#[derive(Debug, Deserialize)]
51pub struct StatusResponse {
52    pub num_documents: u64,
53    pub num_collections: u64,
54}
55
56#[derive(Debug, Deserialize)]
58pub struct CollectionResponse {
59    pub message: String,
60}
61
62#[derive(Debug, Deserialize)]
64pub struct CollectionListResponse {
65    pub collections: Vec<String>,
66}
67
68#[derive(Debug, Deserialize)]
70pub struct DocumentResponse {
71    pub message: String,
72}
73
74#[derive(Debug, Deserialize)]
76pub struct DocumentInfo {
77    pub path: String,
78    pub index_status: IndexStatus,
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub metadata: Option<Metadata>,
81    #[serde(skip_serializing_if = "Option::is_none")]
82    pub content: Option<DocumentContent>,
83}
84
85#[derive(Debug, Deserialize)]
87pub struct DocumentInfoResponse {
88    pub document: DocumentInfo,
89}
90
91#[derive(Debug, Deserialize)]
93pub struct DocumentInfoListResponse {
94    pub documents: Vec<DocumentInfo>,
95    #[serde(skip_serializing_if = "Option::is_none")]
96    pub path_gt: Option<String>,
97}
98
99#[derive(Debug, Deserialize)]
101pub struct PageInfo {
102    pub path: String,
103    pub page_number: u32,
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub content: Option<String>,
106}
107
108#[derive(Debug, Deserialize)]
110pub struct PageInfoResponse {
111    pub page: PageInfo,
112}
113
114#[derive(Debug, Deserialize)]
116pub struct DocumentResult {
117    pub path: String,
118    pub score: f64,
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub metadata: Option<Metadata>,
121}
122
123#[derive(Debug, Deserialize)]
125pub struct TopDocumentsResponse {
126    pub results: Vec<DocumentResult>,
127}
128
129#[derive(Debug, Deserialize)]
131pub struct PageResult {
132    pub path: String,
133    pub page_number: u32,
134    pub score: f64,
135    #[serde(skip_serializing_if = "Option::is_none")]
136    pub content: Option<String>,
137}
138
139#[derive(Debug, Deserialize)]
141pub struct TopPagesResponse {
142    pub results: Vec<PageResult>,
143}
144
145#[derive(Debug, Deserialize)]
147pub struct SnippetResult {
148    pub path: String,
149    pub content: String,
150    pub score: f64,
151    pub page_number: Option<u32>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub metadata: Option<Metadata>,
154}
155
156#[derive(Debug, Deserialize)]
158pub struct TopSnippetsResponse {
159    pub results: Vec<SnippetResult>,
160}
161
162#[derive(Debug, Serialize)]
164pub struct RerankDocument {
165    pub id: String,
166    pub text: String,
167}
168
169#[derive(Debug, Deserialize)]
171pub struct RerankResult {
172    pub id: String,
173    pub score: f64,
174    pub index: usize,
175}
176
177#[derive(Debug, Deserialize)]
179pub struct RerankResponse {
180    pub results: Vec<RerankResult>,
181}