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}