Skip to main content

gproxy_protocol/wire/openai/
files.rs

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