1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct ImageResponse {
8 pub total: u32,
10 #[serde(rename = "totalHits")]
11 pub total_hits: u32,
13 pub hits: Vec<Image>,
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
21pub struct Image {
22 pub id: u64,
24 #[serde(rename = "pageURL")]
25 pub page_url: String,
27 #[serde(rename = "type")]
28 pub image_type: String,
30 pub tags: String,
32 #[serde(rename = "previewURL")]
33 pub preview_url: String,
35 #[serde(rename = "previewWidth")]
36 pub preview_width: u32,
38 #[serde(rename = "previewHeight")]
39 pub preview_height: u32,
41 #[serde(rename = "webformatURL")]
42 pub webformat_url: String,
44 #[serde(rename = "webformatWidth")]
45 pub webformat_width: u32,
47 #[serde(rename = "webformatHeight")]
48 pub webformat_height: u32,
50 #[serde(rename = "largeImageURL")]
51 pub large_image_url: String,
53 #[serde(rename = "fullHDURL", skip_serializing_if = "Option::is_none")]
54 pub full_hd_url: Option<String>,
56 #[serde(rename = "imageURL", skip_serializing_if = "Option::is_none")]
57 pub image_url: Option<String>,
59 #[serde(rename = "vectorURL", skip_serializing_if = "Option::is_none")]
60 pub vector_url: Option<String>,
62 #[serde(rename = "imageWidth")]
63 pub image_width: u32,
65 #[serde(rename = "imageHeight")]
66 pub image_height: u32,
68 #[serde(rename = "imageSize")]
69 pub image_size: u64,
71 pub views: u32,
73 pub downloads: u32,
75 #[serde(skip_serializing_if = "Option::is_none")]
76 pub collections: Option<u32>,
78 pub likes: u32,
80 pub comments: u32,
82 #[serde(rename = "user_id")]
83 pub user_id: u64,
85 pub user: String,
87 #[serde(rename = "userImageURL")]
88 pub user_image_url: String,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
96pub struct VideoResponse {
97 pub total: u32,
99 #[serde(rename = "totalHits")]
100 pub total_hits: u32,
102 pub hits: Vec<Video>,
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct Video {
111 pub id: u64,
113 #[serde(rename = "pageURL")]
114 pub page_url: String,
116 #[serde(rename = "type")]
117 pub video_type: String,
119 pub tags: String,
121 pub duration: u32,
123 pub videos: VideoFiles,
125 pub views: u32,
127 pub downloads: u32,
129 pub likes: u32,
131 pub comments: u32,
133 #[serde(rename = "user_id")]
134 pub user_id: u64,
136 pub user: String,
138 #[serde(rename = "userImageURL")]
139 pub user_image_url: String,
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize)]
147pub struct VideoFiles {
148 pub large: Option<VideoFile>,
150 pub medium: Option<VideoFile>,
152 pub small: Option<VideoFile>,
154 pub tiny: Option<VideoFile>,
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize)]
162pub struct VideoFile {
163 pub url: String,
165 pub width: u32,
167 pub height: u32,
169 pub size: u64,
171 pub thumbnail: String,
173}
174
175#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(rename_all = "snake_case")]
180pub enum ImageType {
181 All,
183 Photo,
185 Illustration,
187 Vector,
189}
190
191impl std::fmt::Display for ImageType {
192 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
193 let s = match self {
194 ImageType::All => "all",
195 ImageType::Photo => "photo",
196 ImageType::Illustration => "illustration",
197 ImageType::Vector => "vector",
198 };
199 f.write_str(s)
200 }
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(rename_all = "snake_case")]
208pub enum VideoType {
209 All,
211 Film,
213 Animation,
215}
216
217impl std::fmt::Display for VideoType {
218 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
219 let s = match self {
220 VideoType::All => "all",
221 VideoType::Film => "film",
222 VideoType::Animation => "animation",
223 };
224 f.write_str(s)
225 }
226}
227
228#[derive(Debug, Clone, Serialize, Deserialize)]
229#[serde(rename_all = "snake_case")]
230pub enum Orientation {
231 All,
232 Horizontal,
233 Vertical,
234}
235
236impl std::fmt::Display for Orientation {
237 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
238 let s = match self {
239 Orientation::All => "all",
240 Orientation::Horizontal => "horizontal",
241 Orientation::Vertical => "vertical",
242 };
243 f.write_str(s)
244 }
245}
246
247#[derive(Debug, Clone, Serialize, Deserialize)]
251#[serde(rename_all = "snake_case")]
252pub enum Category {
253 Backgrounds,
255 Fashion,
257 Nature,
259 Science,
261 Education,
263 Feelings,
265 Health,
267 People,
269 Religion,
271 Places,
273 Animals,
275 Industry,
277 Computer,
279 Food,
281 Sports,
283 Transportation,
285 Travel,
287 Buildings,
289 Business,
291 Music,
293}
294
295impl std::fmt::Display for Category {
296 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
297 let s = match self {
298 Category::Backgrounds => "backgrounds",
299 Category::Fashion => "fashion",
300 Category::Nature => "nature",
301 Category::Science => "science",
302 Category::Education => "education",
303 Category::Feelings => "feelings",
304 Category::Health => "health",
305 Category::People => "people",
306 Category::Religion => "religion",
307 Category::Places => "places",
308 Category::Animals => "animals",
309 Category::Industry => "industry",
310 Category::Computer => "computer",
311 Category::Food => "food",
312 Category::Sports => "sports",
313 Category::Transportation => "transportation",
314 Category::Travel => "travel",
315 Category::Buildings => "buildings",
316 Category::Business => "business",
317 Category::Music => "music",
318 };
319 f.write_str(s)
320 }
321}
322
323#[derive(Debug, Clone, Serialize, Deserialize)]
327#[serde(rename_all = "snake_case")]
328pub enum Order {
329 Popular,
331 Latest,
333}
334
335impl std::fmt::Display for Order {
336 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
337 let s = match self {
338 Order::Popular => "popular",
339 Order::Latest => "latest",
340 };
341 f.write_str(s)
342 }
343}
344
345#[derive(Debug, Clone, Serialize, Deserialize)]
349#[serde(rename_all = "snake_case")]
350pub enum Language {
351 Cs,
353 Da,
355 De,
357 En,
359 Es,
361 Fr,
363 Id,
365 It,
367 Hu,
369 Nl,
371 No,
373 Pl,
375 Pt,
377 Ro,
379 Sk,
381 Fi,
383 Sv,
385 Tr,
387 Vi,
389 Th,
391 Bg,
393 Ru,
395 El,
397 Ja,
399 Ko,
401 Zh,
403}
404
405impl std::fmt::Display for Language {
406 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
407 let s = match self {
408 Language::Cs => "cs",
409 Language::Da => "da",
410 Language::De => "de",
411 Language::En => "en",
412 Language::Es => "es",
413 Language::Fr => "fr",
414 Language::Id => "id",
415 Language::It => "it",
416 Language::Hu => "hu",
417 Language::Nl => "nl",
418 Language::No => "no",
419 Language::Pl => "pl",
420 Language::Pt => "pt",
421 Language::Ro => "ro",
422 Language::Sk => "sk",
423 Language::Fi => "fi",
424 Language::Sv => "sv",
425 Language::Tr => "tr",
426 Language::Vi => "vi",
427 Language::Th => "th",
428 Language::Bg => "bg",
429 Language::Ru => "ru",
430 Language::El => "el",
431 Language::Ja => "ja",
432 Language::Ko => "ko",
433 Language::Zh => "zh",
434 };
435 f.write_str(s)
436 }
437}