zeroentropy_community/
types.rs

1use serde::{Deserialize, Serialize};
2use std::collections::HashMap;
3
4/// Document content types
5#[derive(Debug, Clone, Serialize, Deserialize)]
6#[serde(tag = "type", rename_all = "lowercase")]
7pub enum DocumentContent {
8    /// Plain text content
9    Text { text: String },
10    /// Auto-detect format (for PDFs, images with OCR)
11    Auto { base64_data: String },
12}
13
14/// Metadata type for documents
15pub type Metadata = HashMap<String, MetadataValue>;
16
17/// Metadata values can be strings or arrays of strings
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum MetadataValue {
21    String(String),
22    Array(Vec<String>),
23}
24
25/// Filter for querying documents
26pub type Filter = HashMap<String, serde_json::Value>;
27
28/// Latency mode for queries
29#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
30#[serde(rename_all = "lowercase")]
31pub enum LatencyMode {
32    Low,
33    High,
34}
35
36/// Index status for documents
37#[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/// Response from status endpoint
50#[derive(Debug, Deserialize)]
51pub struct StatusResponse {
52    pub num_documents: u64,
53    pub num_collections: u64,
54}
55
56/// Response from collection add/delete
57#[derive(Debug, Deserialize)]
58pub struct CollectionResponse {
59    pub message: String,
60}
61
62/// Response from get collection list
63#[derive(Debug, Deserialize)]
64pub struct CollectionListResponse {
65    pub collections: Vec<String>,
66}
67
68/// Response from document add/update/delete
69#[derive(Debug, Deserialize)]
70pub struct DocumentResponse {
71    pub message: String,
72}
73
74/// Document information
75#[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/// Response from get document info
86#[derive(Debug, Deserialize)]
87pub struct DocumentInfoResponse {
88    pub document: DocumentInfo,
89}
90
91/// Response from get document info list
92#[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/// Page information
100#[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/// Response from get page info
109#[derive(Debug, Deserialize)]
110pub struct PageInfoResponse {
111    pub page: PageInfo,
112}
113
114/// Query result for top documents
115#[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/// Response from top documents query
124#[derive(Debug, Deserialize)]
125pub struct TopDocumentsResponse {
126    pub results: Vec<DocumentResult>,
127}
128
129/// Query result for top pages
130#[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/// Response from top pages query
140#[derive(Debug, Deserialize)]
141pub struct TopPagesResponse {
142    pub results: Vec<PageResult>,
143}
144
145/// Query result for top snippets
146#[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/// Response from top snippets query
157#[derive(Debug, Deserialize)]
158pub struct TopSnippetsResponse {
159    pub results: Vec<SnippetResult>,
160}
161
162/// Document for reranking
163#[derive(Debug, Serialize)]
164pub struct RerankDocument {
165    pub id: String,
166    pub text: String,
167}
168
169/// Rerank result
170#[derive(Debug, Deserialize)]
171pub struct RerankResult {
172    pub id: String,
173    pub score: f64,
174    pub index: usize,
175}
176
177/// Response from rerank endpoint
178#[derive(Debug, Deserialize)]
179pub struct RerankResponse {
180    pub results: Vec<RerankResult>,
181}