1use crate::connection::{HttpBody, MultipartPart};
5use crate::{Rest, WireRequest, WireResponse};
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
9#[serde(rename_all = "snake_case")]
10#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
11#[derive(gproxy_protocol_macros::DeclaredFields)]
12#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13pub struct FileObject {
14 pub id: String,
15 pub bytes: i64,
16 pub created_at: i64,
17 pub filename: String,
18 pub object: FileObjectType,
19 pub purpose: FilePurpose,
20 pub status: FileStatus,
21 #[serde(
22 default,
23 deserialize_with = "present_nullable",
24 skip_serializing_if = "Option::is_none"
25 )]
26 pub status_details: Option<Option<String>>,
27 #[serde(
28 default,
29 deserialize_with = "present_nullable",
30 skip_serializing_if = "Option::is_none"
31 )]
32 pub expires_at: Option<Option<i64>>,
33 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
34 pub rest: Rest,
35}
36#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
37#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
38#[derive(gproxy_protocol_macros::DeclaredFields)]
39#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
40pub enum FileObjectType {
41 #[serde(rename = "file")]
42 File,
43}
44#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
45#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
46#[derive(gproxy_protocol_macros::DeclaredFields)]
47#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
48pub enum FilePurpose {
49 #[serde(rename = "assistants")]
50 Assistants,
51 #[serde(rename = "batch")]
52 Batch,
53 #[serde(rename = "fine-tune")]
54 FineTune,
55 #[serde(rename = "vision")]
56 Vision,
57 #[serde(rename = "user_data")]
58 UserData,
59 #[serde(rename = "assistants_output")]
60 AssistantsOutput,
61 #[serde(rename = "batch_output")]
62 BatchOutput,
63 #[serde(rename = "fine-tune-results")]
64 FineTuneResults,
65}
66#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
67#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
68#[derive(gproxy_protocol_macros::DeclaredFields)]
69#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
70pub enum FileStatus {
71 #[serde(rename = "uploaded")]
72 Uploaded,
73 #[serde(rename = "processed")]
74 Processed,
75 #[serde(rename = "error")]
76 Error,
77}
78#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
79#[serde(rename_all = "snake_case")]
80#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
81#[derive(gproxy_protocol_macros::DeclaredFields)]
82#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
83pub struct ListFilesQuery {
84 #[serde(
85 default,
86 deserialize_with = "present_optional",
87 skip_serializing_if = "Option::is_none"
88 )]
89 pub purpose: Option<String>,
90 #[serde(
91 default,
92 deserialize_with = "present_optional",
93 skip_serializing_if = "Option::is_none"
94 )]
95 pub limit: Option<i64>,
96 #[serde(
97 default,
98 deserialize_with = "present_optional",
99 skip_serializing_if = "Option::is_none"
100 )]
101 pub order: Option<FileOrder>,
102 #[serde(
103 default,
104 deserialize_with = "present_optional",
105 skip_serializing_if = "Option::is_none"
106 )]
107 pub after: Option<String>,
108 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
109 pub rest: Rest,
110}
111#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
112#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
113#[derive(gproxy_protocol_macros::DeclaredFields)]
114#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
115pub enum FileOrder {
116 #[serde(rename = "asc")]
117 Asc,
118 #[serde(rename = "desc")]
119 Desc,
120}
121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
122#[serde(rename_all = "snake_case")]
123#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
124#[derive(gproxy_protocol_macros::DeclaredFields)]
125#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
126pub struct ListFilesResponseBody {
127 pub object: String,
129 pub data: Vec<FileObject>,
130 pub has_more: bool,
131 pub first_id: String,
132 pub last_id: String,
133 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
134 pub rest: Rest,
135}
136
137#[derive(
138 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
139)]
140#[serde(rename_all = "snake_case")]
141#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
142#[derive(gproxy_protocol_macros::DeclaredFields)]
143#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
144pub struct DeleteFileResponseBody {
145 pub id: String,
146 pub object: DeletedFileObject,
147 pub deleted: bool,
148 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
149 pub rest: Rest,
150}
151#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
152#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
153#[derive(gproxy_protocol_macros::DeclaredFields)]
154#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
155pub enum DeletedFileObject {
156 #[serde(rename = "file")]
157 File,
158}
159#[derive(Debug, gproxy_protocol_macros::WireBuilder)]
160#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
161#[derive(gproxy_protocol_macros::DeclaredFields)]
162#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
163pub struct UploadFileForm {
164 pub file: MultipartPart,
165 pub purpose: UploadFilePurpose,
166 pub expires_after: Option<FileExpiry>,
167}
168pub type UploadFileRequest = WireRequest<UploadFileForm>;
169pub type RawUploadFileRequest = WireRequest<crate::connection::Multipart>;
170pub type UploadFileResponse = WireResponse<FileObject>;
171pub type ListFilesRequest = WireRequest<()>;
172pub type ListFilesResponse = WireResponse<ListFilesResponseBody>;
173pub type ListFilesWireResponse = WireResponse<ListFilesResponseBody>;
174pub type RetrieveFileRequest = WireRequest<()>;
175pub type RetrieveFileResponse = WireResponse<FileObject>;
176pub type RetrieveFileContentRequest = WireRequest<()>;
177pub type RetrieveFileContentResponse = WireResponse<HttpBody>;
178pub type DeleteFileRequest = WireRequest<()>;
179pub type DeleteFileResponse = WireResponse<DeleteFileResponseBody>;
180pub type DeleteFileWireResponse = DeleteFileResponse;
181
182#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
183#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
184#[derive(gproxy_protocol_macros::DeclaredFields)]
185#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
186pub enum UploadFilePurpose {
187 #[serde(rename = "assistants")]
188 Assistants,
189 #[serde(rename = "batch")]
190 Batch,
191 #[serde(rename = "fine-tune")]
192 FineTune,
193 #[serde(rename = "vision")]
194 Vision,
195 #[serde(rename = "user_data")]
196 UserData,
197 #[serde(rename = "evals")]
198 Evals,
199}
200#[derive(
201 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
202)]
203#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
204#[derive(gproxy_protocol_macros::DeclaredFields)]
205#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
206pub struct FileExpiry {
207 pub anchor: FileExpiryAnchor,
208 pub seconds: i64,
209 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
210 pub rest: Rest,
211}
212#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
213#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
214#[derive(gproxy_protocol_macros::DeclaredFields)]
215#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
216pub enum FileExpiryAnchor {
217 #[serde(rename = "created_at")]
218 CreatedAt,
219}
220
221fn present_optional<'de, D, T>(d: D) -> Result<Option<T>, D::Error>
222where
223 D: serde::Deserializer<'de>,
224 T: Deserialize<'de>,
225{
226 T::deserialize(d).map(Some)
227}
228fn present_nullable<'de, D, T>(d: D) -> Result<Option<Option<T>>, D::Error>
229where
230 D: serde::Deserializer<'de>,
231 T: Deserialize<'de>,
232{
233 Option::<T>::deserialize(d).map(Some)
234}