1use crate::client::Client;
2use crate::errors::Error;
3use crate::Result;
4use reqwest::header::{HeaderMap, HeaderValue};
5use reqwest::Method;
6use serde_json::Value;
7use tracing::instrument;
8use urlencoding::encode;
9#[derive(Debug, Clone)]
10pub struct ClipzyZaiXianJianTieBanService<'a> {
11 pub(crate) client: &'a Client,
12}
13
14impl<'a> ClipzyZaiXianJianTieBanService<'a> {
15#[instrument(skip(self, params))]
17 pub async fn get_clipzy_get(&self, params: GetClipzyGetParams) -> Result<Value> {
18 let mut path = "/api/v1/api/get".to_string();
19
20 let mut query: Vec<(String, String)> = Vec::new();
21 query.push(("id".to_string(), params.id_query.clone()));
22 let query = if query.is_empty() { None } else { Some(query) };
23
24 let mut extra_headers = HeaderMap::new();
25 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
26 let body = None;
27
28 self.client
29 .request_json(
30 Method::GET,
31 &path,
32 headers,
33 query,
34 body,
35 )
36 .await
37 }
38#[instrument(skip(self, params))]
40 pub async fn get_clipzy_raw(&self, params: GetClipzyRawParams) -> Result<Value> {
41 let mut path = "/api/v1/api/raw/{id}".to_string();
42 {
43 let encoded = encode(¶ms.id_path).into_owned();
44 path = path.replace("{id}", &encoded);
45 }
46
47 let mut query: Vec<(String, String)> = Vec::new();
48 query.push(("key".to_string(), params.key_query.clone()));
49 let query = if query.is_empty() { None } else { Some(query) };
50
51 let mut extra_headers = HeaderMap::new();
52 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
53 let body = None;
54
55 self.client
56 .request_json(
57 Method::GET,
58 &path,
59 headers,
60 query,
61 body,
62 )
63 .await
64 }
65#[instrument(skip(self, params))]
67 pub async fn post_clipzy_store(&self, params: PostClipzyStoreParams) -> Result<Value> {
68 let mut path = "/api/v1/api/store".to_string();
69
70 let mut query: Vec<(String, String)> = Vec::new();
71 let query = if query.is_empty() { None } else { Some(query) };
72
73 let mut extra_headers = HeaderMap::new();
74 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
75 let body = params.body.clone();
76
77 self.client
78 .request_json(
79 Method::POST,
80 &path,
81 headers,
82 query,
83 body,
84 )
85 .await
86 }
87}
88
89#[derive(Debug, Clone)]
90pub struct GetClipzyGetParams {
91 pub id_query: String,
92}
93
94impl GetClipzyGetParams {
95 pub fn new(id_query: impl Into<String>) -> Self {
96 Self {
97 id_query: id_query.into(),
98 }
99 }
100}
101
102#[derive(Debug, Clone)]
103pub struct GetClipzyRawParams {
104 pub id_path: String,
105 pub key_query: String,
106}
107
108impl GetClipzyRawParams {
109 pub fn new(id_path: impl Into<String>, key_query: impl Into<String>) -> Self {
110 Self {
111 id_path: id_path.into(),
112 key_query: key_query.into(),
113 }
114 }
115}
116
117#[derive(Debug, Clone)]
118pub struct PostClipzyStoreParams {
119 pub body: Option<Value>,
120}
121
122impl PostClipzyStoreParams {
123 pub fn new() -> Self {
124 Self {
125 body: None,
126 }
127 }
128 pub fn body(mut self, value: Value) -> Self {
129 self.body = Some(value);
130 self
131 }
132}
133#[derive(Debug, Clone)]
134pub struct ConvertService<'a> {
135 pub(crate) client: &'a Client,
136}
137
138impl<'a> ConvertService<'a> {
139#[instrument(skip(self, params))]
141 pub async fn get_convert_unixtime(&self, params: GetConvertUnixtimeParams) -> Result<Value> {
142 let mut path = "/api/v1/convert/unixtime".to_string();
143
144 let mut query: Vec<(String, String)> = Vec::new();
145 query.push(("time".to_string(), params.time_query.clone()));
146 let query = if query.is_empty() { None } else { Some(query) };
147
148 let mut extra_headers = HeaderMap::new();
149 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
150 let body = None;
151
152 self.client
153 .request_json(
154 Method::GET,
155 &path,
156 headers,
157 query,
158 body,
159 )
160 .await
161 }
162#[instrument(skip(self, params))]
164 pub async fn post_convert_json(&self, params: PostConvertJsonParams) -> Result<Value> {
165 let mut path = "/api/v1/convert/json".to_string();
166
167 let mut query: Vec<(String, String)> = Vec::new();
168 let query = if query.is_empty() { None } else { Some(query) };
169
170 let mut extra_headers = HeaderMap::new();
171 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
172 let body = params.body.clone();
173
174 self.client
175 .request_json(
176 Method::POST,
177 &path,
178 headers,
179 query,
180 body,
181 )
182 .await
183 }
184}
185
186#[derive(Debug, Clone)]
187pub struct GetConvertUnixtimeParams {
188 pub time_query: String,
189}
190
191impl GetConvertUnixtimeParams {
192 pub fn new(time_query: impl Into<String>) -> Self {
193 Self {
194 time_query: time_query.into(),
195 }
196 }
197}
198
199#[derive(Debug, Clone)]
200pub struct PostConvertJsonParams {
201 pub body: Option<Value>,
202}
203
204impl PostConvertJsonParams {
205 pub fn new() -> Self {
206 Self {
207 body: None,
208 }
209 }
210 pub fn body(mut self, value: Value) -> Self {
211 self.body = Some(value);
212 self
213 }
214}
215#[derive(Debug, Clone)]
216pub struct DailyService<'a> {
217 pub(crate) client: &'a Client,
218}
219
220impl<'a> DailyService<'a> {
221#[instrument(skip(self))]
223 pub async fn get_daily_news_image(&self) -> Result<Value> {
224 let mut path = "/api/v1/daily/news-image".to_string();
225
226 let mut query: Vec<(String, String)> = Vec::new();
227 let query = if query.is_empty() { None } else { Some(query) };
228
229 let mut extra_headers = HeaderMap::new();
230 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
231 let body = None;
232
233 self.client
234 .request_json(
235 Method::GET,
236 &path,
237 headers,
238 query,
239 body,
240 )
241 .await
242 }
243}
244
245#[derive(Debug, Clone)]
246pub struct GameService<'a> {
247 pub(crate) client: &'a Client,
248}
249
250impl<'a> GameService<'a> {
251#[instrument(skip(self))]
253 pub async fn get_game_epic_free(&self) -> Result<Value> {
254 let mut path = "/api/v1/game/epic-free".to_string();
255
256 let mut query: Vec<(String, String)> = Vec::new();
257 let query = if query.is_empty() { None } else { Some(query) };
258
259 let mut extra_headers = HeaderMap::new();
260 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
261 let body = None;
262
263 self.client
264 .request_json(
265 Method::GET,
266 &path,
267 headers,
268 query,
269 body,
270 )
271 .await
272 }
273#[instrument(skip(self, params))]
275 pub async fn get_game_minecraft_historyid(&self, params: GetGameMinecraftHistoryidParams) -> Result<Value> {
276 let mut path = "/api/v1/game/minecraft/historyid".to_string();
277
278 let mut query: Vec<(String, String)> = Vec::new();
279 if let Some(value) = ¶ms.name_query {
280 query.push(("name".to_string(), value.clone()));
281 }
282 if let Some(value) = ¶ms.uuid_query {
283 query.push(("uuid".to_string(), value.clone()));
284 }
285 let query = if query.is_empty() { None } else { Some(query) };
286
287 let mut extra_headers = HeaderMap::new();
288 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
289 let body = None;
290
291 self.client
292 .request_json(
293 Method::GET,
294 &path,
295 headers,
296 query,
297 body,
298 )
299 .await
300 }
301#[instrument(skip(self, params))]
303 pub async fn get_game_minecraft_serverstatus(&self, params: GetGameMinecraftServerstatusParams) -> Result<Value> {
304 let mut path = "/api/v1/game/minecraft/serverstatus".to_string();
305
306 let mut query: Vec<(String, String)> = Vec::new();
307 query.push(("server".to_string(), params.server_query.clone()));
308 let query = if query.is_empty() { None } else { Some(query) };
309
310 let mut extra_headers = HeaderMap::new();
311 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
312 let body = None;
313
314 self.client
315 .request_json(
316 Method::GET,
317 &path,
318 headers,
319 query,
320 body,
321 )
322 .await
323 }
324#[instrument(skip(self, params))]
326 pub async fn get_game_minecraft_userinfo(&self, params: GetGameMinecraftUserinfoParams) -> Result<Value> {
327 let mut path = "/api/v1/game/minecraft/userinfo".to_string();
328
329 let mut query: Vec<(String, String)> = Vec::new();
330 query.push(("username".to_string(), params.username_query.clone()));
331 let query = if query.is_empty() { None } else { Some(query) };
332
333 let mut extra_headers = HeaderMap::new();
334 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
335 let body = None;
336
337 self.client
338 .request_json(
339 Method::GET,
340 &path,
341 headers,
342 query,
343 body,
344 )
345 .await
346 }
347#[instrument(skip(self, params))]
349 pub async fn get_game_steam_summary(&self, params: GetGameSteamSummaryParams) -> Result<Value> {
350 let mut path = "/api/v1/game/steam/summary".to_string();
351
352 let mut query: Vec<(String, String)> = Vec::new();
353 if let Some(value) = ¶ms.steamid_query {
354 query.push(("steamid".to_string(), value.clone()));
355 }
356 if let Some(value) = ¶ms.id_query {
357 query.push(("id".to_string(), value.clone()));
358 }
359 if let Some(value) = ¶ms.id_3_query {
360 query.push(("id3".to_string(), value.clone()));
361 }
362 if let Some(value) = ¶ms.key_query {
363 query.push(("key".to_string(), value.clone()));
364 }
365 let query = if query.is_empty() { None } else { Some(query) };
366
367 let mut extra_headers = HeaderMap::new();
368 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
369 let body = None;
370
371 self.client
372 .request_json(
373 Method::GET,
374 &path,
375 headers,
376 query,
377 body,
378 )
379 .await
380 }
381}
382
383
384#[derive(Debug, Clone)]
385pub struct GetGameMinecraftHistoryidParams {
386 pub name_query: Option<String>,
387 pub uuid_query: Option<String>,
388}
389
390impl GetGameMinecraftHistoryidParams {
391 pub fn new() -> Self {
392 Self {
393 name_query: None,
394 uuid_query: None,
395 }
396 }
397 pub fn name_query(mut self, value: impl Into<String>) -> Self {
398 self.name_query = Some(value.into());
399 self
400 }
401 pub fn uuid_query(mut self, value: impl Into<String>) -> Self {
402 self.uuid_query = Some(value.into());
403 self
404 }
405}
406
407#[derive(Debug, Clone)]
408pub struct GetGameMinecraftServerstatusParams {
409 pub server_query: String,
410}
411
412impl GetGameMinecraftServerstatusParams {
413 pub fn new(server_query: impl Into<String>) -> Self {
414 Self {
415 server_query: server_query.into(),
416 }
417 }
418}
419
420#[derive(Debug, Clone)]
421pub struct GetGameMinecraftUserinfoParams {
422 pub username_query: String,
423}
424
425impl GetGameMinecraftUserinfoParams {
426 pub fn new(username_query: impl Into<String>) -> Self {
427 Self {
428 username_query: username_query.into(),
429 }
430 }
431}
432
433#[derive(Debug, Clone)]
434pub struct GetGameSteamSummaryParams {
435 pub steamid_query: Option<String>,
436 pub id_query: Option<String>,
437 pub id_3_query: Option<String>,
438 pub key_query: Option<String>,
439}
440
441impl GetGameSteamSummaryParams {
442 pub fn new() -> Self {
443 Self {
444 steamid_query: None,
445 id_query: None,
446 id_3_query: None,
447 key_query: None,
448 }
449 }
450 pub fn steamid_query(mut self, value: impl Into<String>) -> Self {
451 self.steamid_query = Some(value.into());
452 self
453 }
454 pub fn id_query(mut self, value: impl Into<String>) -> Self {
455 self.id_query = Some(value.into());
456 self
457 }
458 pub fn id_3_query(mut self, value: impl Into<String>) -> Self {
459 self.id_3_query = Some(value.into());
460 self
461 }
462 pub fn key_query(mut self, value: impl Into<String>) -> Self {
463 self.key_query = Some(value.into());
464 self
465 }
466}
467#[derive(Debug, Clone)]
468pub struct ImageService<'a> {
469 pub(crate) client: &'a Client,
470}
471
472impl<'a> ImageService<'a> {
473#[instrument(skip(self, params))]
475 pub async fn get_avatar_gravatar(&self, params: GetAvatarGravatarParams) -> Result<Value> {
476 let mut path = "/api/v1/avatar/gravatar".to_string();
477
478 let mut query: Vec<(String, String)> = Vec::new();
479 if let Some(value) = ¶ms.email_query {
480 query.push(("email".to_string(), value.clone()));
481 }
482 if let Some(value) = ¶ms.hash_query {
483 query.push(("hash".to_string(), value.clone()));
484 }
485 if let Some(value) = ¶ms.s_query {
486 query.push(("s".to_string(), value.clone()));
487 }
488 if let Some(value) = ¶ms.d_query {
489 query.push(("d".to_string(), value.clone()));
490 }
491 if let Some(value) = ¶ms.r_query {
492 query.push(("r".to_string(), value.clone()));
493 }
494 let query = if query.is_empty() { None } else { Some(query) };
495
496 let mut extra_headers = HeaderMap::new();
497 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
498 let body = None;
499
500 self.client
501 .request_json(
502 Method::GET,
503 &path,
504 headers,
505 query,
506 body,
507 )
508 .await
509 }
510#[instrument(skip(self))]
512 pub async fn get_image_bing_daily(&self) -> Result<Value> {
513 let mut path = "/api/v1/image/bing-daily".to_string();
514
515 let mut query: Vec<(String, String)> = Vec::new();
516 let query = if query.is_empty() { None } else { Some(query) };
517
518 let mut extra_headers = HeaderMap::new();
519 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
520 let body = None;
521
522 self.client
523 .request_json(
524 Method::GET,
525 &path,
526 headers,
527 query,
528 body,
529 )
530 .await
531 }
532#[instrument(skip(self, params))]
534 pub async fn get_image_motou(&self, params: GetImageMotouParams) -> Result<Value> {
535 let mut path = "/api/v1/image/motou".to_string();
536
537 let mut query: Vec<(String, String)> = Vec::new();
538 query.push(("qq".to_string(), params.qq_query.clone()));
539 if let Some(value) = ¶ms.bg_color_query {
540 query.push(("bg_color".to_string(), value.clone()));
541 }
542 let query = if query.is_empty() { None } else { Some(query) };
543
544 let mut extra_headers = HeaderMap::new();
545 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
546 let body = None;
547
548 self.client
549 .request_json(
550 Method::GET,
551 &path,
552 headers,
553 query,
554 body,
555 )
556 .await
557 }
558#[instrument(skip(self, params))]
560 pub async fn get_image_qrcode(&self, params: GetImageQrcodeParams) -> Result<Value> {
561 let mut path = "/api/v1/image/qrcode".to_string();
562
563 let mut query: Vec<(String, String)> = Vec::new();
564 query.push(("text".to_string(), params.text_query.clone()));
565 if let Some(value) = ¶ms.size_query {
566 query.push(("size".to_string(), value.clone()));
567 }
568 if let Some(value) = ¶ms.format_query {
569 query.push(("format".to_string(), value.clone()));
570 }
571 let query = if query.is_empty() { None } else { Some(query) };
572
573 let mut extra_headers = HeaderMap::new();
574 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
575 let body = None;
576
577 self.client
578 .request_json(
579 Method::GET,
580 &path,
581 headers,
582 query,
583 body,
584 )
585 .await
586 }
587#[instrument(skip(self, params))]
589 pub async fn get_image_tobase_64(&self, params: GetImageTobase64Params) -> Result<Value> {
590 let mut path = "/api/v1/image/tobase64".to_string();
591
592 let mut query: Vec<(String, String)> = Vec::new();
593 query.push(("url".to_string(), params.url_query.clone()));
594 let query = if query.is_empty() { None } else { Some(query) };
595
596 let mut extra_headers = HeaderMap::new();
597 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
598 let body = None;
599
600 self.client
601 .request_json(
602 Method::GET,
603 &path,
604 headers,
605 query,
606 body,
607 )
608 .await
609 }
610#[instrument(skip(self, params))]
612 pub async fn post_image_compress(&self, params: PostImageCompressParams) -> Result<Value> {
613 let mut path = "/api/v1/image/compress".to_string();
614
615 let mut query: Vec<(String, String)> = Vec::new();
616 if let Some(value) = ¶ms.level_query {
617 query.push(("level".to_string(), value.clone()));
618 }
619 if let Some(value) = ¶ms.format_query {
620 query.push(("format".to_string(), value.clone()));
621 }
622 let query = if query.is_empty() { None } else { Some(query) };
623
624 let mut extra_headers = HeaderMap::new();
625 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
626 let body = params.body.clone();
627
628 self.client
629 .request_json(
630 Method::POST,
631 &path,
632 headers,
633 query,
634 body,
635 )
636 .await
637 }
638#[instrument(skip(self, params))]
640 pub async fn post_image_frombase_64(&self, params: PostImageFrombase64Params) -> Result<Value> {
641 let mut path = "/api/v1/image/frombase64".to_string();
642
643 let mut query: Vec<(String, String)> = Vec::new();
644 let query = if query.is_empty() { None } else { Some(query) };
645
646 let mut extra_headers = HeaderMap::new();
647 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
648 let body = params.body.clone();
649
650 self.client
651 .request_json(
652 Method::POST,
653 &path,
654 headers,
655 query,
656 body,
657 )
658 .await
659 }
660#[instrument(skip(self, params))]
662 pub async fn post_image_motou(&self, params: PostImageMotouParams) -> Result<Value> {
663 let mut path = "/api/v1/image/motou".to_string();
664
665 let mut query: Vec<(String, String)> = Vec::new();
666 let query = if query.is_empty() { None } else { Some(query) };
667
668 let mut extra_headers = HeaderMap::new();
669 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
670 let body = params.body.clone();
671
672 self.client
673 .request_json(
674 Method::POST,
675 &path,
676 headers,
677 query,
678 body,
679 )
680 .await
681 }
682#[instrument(skip(self, params))]
684 pub async fn post_image_speechless(&self, params: PostImageSpeechlessParams) -> Result<Value> {
685 let mut path = "/api/v1/image/speechless".to_string();
686
687 let mut query: Vec<(String, String)> = Vec::new();
688 let query = if query.is_empty() { None } else { Some(query) };
689
690 let mut extra_headers = HeaderMap::new();
691 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
692 let body = params.body.clone();
693
694 self.client
695 .request_json(
696 Method::POST,
697 &path,
698 headers,
699 query,
700 body,
701 )
702 .await
703 }
704#[instrument(skip(self, params))]
706 pub async fn post_image_svg(&self, params: PostImageSvgParams) -> Result<Value> {
707 let mut path = "/api/v1/image/svg".to_string();
708
709 let mut query: Vec<(String, String)> = Vec::new();
710 if let Some(value) = ¶ms.format_query {
711 query.push(("format".to_string(), value.clone()));
712 }
713 if let Some(value) = ¶ms.width_query {
714 query.push(("width".to_string(), value.clone()));
715 }
716 if let Some(value) = ¶ms.height_query {
717 query.push(("height".to_string(), value.clone()));
718 }
719 if let Some(value) = ¶ms.quality_query {
720 query.push(("quality".to_string(), value.clone()));
721 }
722 let query = if query.is_empty() { None } else { Some(query) };
723
724 let mut extra_headers = HeaderMap::new();
725 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
726 let body = params.body.clone();
727
728 self.client
729 .request_json(
730 Method::POST,
731 &path,
732 headers,
733 query,
734 body,
735 )
736 .await
737 }
738}
739
740#[derive(Debug, Clone)]
741pub struct GetAvatarGravatarParams {
742 pub email_query: Option<String>,
743 pub hash_query: Option<String>,
744 pub s_query: Option<String>,
745 pub d_query: Option<String>,
746 pub r_query: Option<String>,
747}
748
749impl GetAvatarGravatarParams {
750 pub fn new() -> Self {
751 Self {
752 email_query: None,
753 hash_query: None,
754 s_query: None,
755 d_query: None,
756 r_query: None,
757 }
758 }
759 pub fn email_query(mut self, value: impl Into<String>) -> Self {
760 self.email_query = Some(value.into());
761 self
762 }
763 pub fn hash_query(mut self, value: impl Into<String>) -> Self {
764 self.hash_query = Some(value.into());
765 self
766 }
767 pub fn s_query(mut self, value: impl Into<String>) -> Self {
768 self.s_query = Some(value.into());
769 self
770 }
771 pub fn d_query(mut self, value: impl Into<String>) -> Self {
772 self.d_query = Some(value.into());
773 self
774 }
775 pub fn r_query(mut self, value: impl Into<String>) -> Self {
776 self.r_query = Some(value.into());
777 self
778 }
779}
780
781
782#[derive(Debug, Clone)]
783pub struct GetImageMotouParams {
784 pub qq_query: String,
785 pub bg_color_query: Option<String>,
786}
787
788impl GetImageMotouParams {
789 pub fn new(qq_query: impl Into<String>) -> Self {
790 Self {
791 qq_query: qq_query.into(),
792 bg_color_query: None,
793 }
794 }
795 pub fn bg_color_query(mut self, value: impl Into<String>) -> Self {
796 self.bg_color_query = Some(value.into());
797 self
798 }
799}
800
801#[derive(Debug, Clone)]
802pub struct GetImageQrcodeParams {
803 pub text_query: String,
804 pub size_query: Option<String>,
805 pub format_query: Option<String>,
806}
807
808impl GetImageQrcodeParams {
809 pub fn new(text_query: impl Into<String>) -> Self {
810 Self {
811 text_query: text_query.into(),
812 size_query: None,
813 format_query: None,
814 }
815 }
816 pub fn size_query(mut self, value: impl Into<String>) -> Self {
817 self.size_query = Some(value.into());
818 self
819 }
820 pub fn format_query(mut self, value: impl Into<String>) -> Self {
821 self.format_query = Some(value.into());
822 self
823 }
824}
825
826#[derive(Debug, Clone)]
827pub struct GetImageTobase64Params {
828 pub url_query: String,
829}
830
831impl GetImageTobase64Params {
832 pub fn new(url_query: impl Into<String>) -> Self {
833 Self {
834 url_query: url_query.into(),
835 }
836 }
837}
838
839#[derive(Debug, Clone)]
840pub struct PostImageCompressParams {
841 pub level_query: Option<String>,
842 pub format_query: Option<String>,
843 pub body: Option<Value>,
844}
845
846impl PostImageCompressParams {
847 pub fn new() -> Self {
848 Self {
849 level_query: None,
850 format_query: None,
851 body: None,
852 }
853 }
854 pub fn level_query(mut self, value: impl Into<String>) -> Self {
855 self.level_query = Some(value.into());
856 self
857 }
858 pub fn format_query(mut self, value: impl Into<String>) -> Self {
859 self.format_query = Some(value.into());
860 self
861 }
862 pub fn body(mut self, value: Value) -> Self {
863 self.body = Some(value);
864 self
865 }
866}
867
868#[derive(Debug, Clone)]
869pub struct PostImageFrombase64Params {
870 pub body: Option<Value>,
871}
872
873impl PostImageFrombase64Params {
874 pub fn new() -> Self {
875 Self {
876 body: None,
877 }
878 }
879 pub fn body(mut self, value: Value) -> Self {
880 self.body = Some(value);
881 self
882 }
883}
884
885#[derive(Debug, Clone)]
886pub struct PostImageMotouParams {
887 pub body: Option<Value>,
888}
889
890impl PostImageMotouParams {
891 pub fn new() -> Self {
892 Self {
893 body: None,
894 }
895 }
896 pub fn body(mut self, value: Value) -> Self {
897 self.body = Some(value);
898 self
899 }
900}
901
902#[derive(Debug, Clone)]
903pub struct PostImageSpeechlessParams {
904 pub body: Option<Value>,
905}
906
907impl PostImageSpeechlessParams {
908 pub fn new() -> Self {
909 Self {
910 body: None,
911 }
912 }
913 pub fn body(mut self, value: Value) -> Self {
914 self.body = Some(value);
915 self
916 }
917}
918
919#[derive(Debug, Clone)]
920pub struct PostImageSvgParams {
921 pub format_query: Option<String>,
922 pub width_query: Option<String>,
923 pub height_query: Option<String>,
924 pub quality_query: Option<String>,
925 pub body: Option<Value>,
926}
927
928impl PostImageSvgParams {
929 pub fn new() -> Self {
930 Self {
931 format_query: None,
932 width_query: None,
933 height_query: None,
934 quality_query: None,
935 body: None,
936 }
937 }
938 pub fn format_query(mut self, value: impl Into<String>) -> Self {
939 self.format_query = Some(value.into());
940 self
941 }
942 pub fn width_query(mut self, value: impl Into<String>) -> Self {
943 self.width_query = Some(value.into());
944 self
945 }
946 pub fn height_query(mut self, value: impl Into<String>) -> Self {
947 self.height_query = Some(value.into());
948 self
949 }
950 pub fn quality_query(mut self, value: impl Into<String>) -> Self {
951 self.quality_query = Some(value.into());
952 self
953 }
954 pub fn body(mut self, value: Value) -> Self {
955 self.body = Some(value);
956 self
957 }
958}
959#[derive(Debug, Clone)]
960pub struct MiscService<'a> {
961 pub(crate) client: &'a Client,
962}
963
964impl<'a> MiscService<'a> {
965#[instrument(skip(self, params))]
967 pub async fn get_history_programmer(&self, params: GetHistoryProgrammerParams) -> Result<Value> {
968 let mut path = "/api/v1/history/programmer".to_string();
969
970 let mut query: Vec<(String, String)> = Vec::new();
971 query.push(("month".to_string(), params.month_query.clone()));
972 query.push(("day".to_string(), params.day_query.clone()));
973 let query = if query.is_empty() { None } else { Some(query) };
974
975 let mut extra_headers = HeaderMap::new();
976 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
977 let body = None;
978
979 self.client
980 .request_json(
981 Method::GET,
982 &path,
983 headers,
984 query,
985 body,
986 )
987 .await
988 }
989#[instrument(skip(self))]
991 pub async fn get_history_programmer_today(&self) -> Result<Value> {
992 let mut path = "/api/v1/history/programmer/today".to_string();
993
994 let mut query: Vec<(String, String)> = Vec::new();
995 let query = if query.is_empty() { None } else { Some(query) };
996
997 let mut extra_headers = HeaderMap::new();
998 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
999 let body = None;
1000
1001 self.client
1002 .request_json(
1003 Method::GET,
1004 &path,
1005 headers,
1006 query,
1007 body,
1008 )
1009 .await
1010 }
1011#[instrument(skip(self, params))]
1013 pub async fn get_misc_hotboard(&self, params: GetMiscHotboardParams) -> Result<Value> {
1014 let mut path = "/api/v1/misc/hotboard".to_string();
1015
1016 let mut query: Vec<(String, String)> = Vec::new();
1017 query.push(("type".to_string(), params.type_query.clone()));
1018 let query = if query.is_empty() { None } else { Some(query) };
1019
1020 let mut extra_headers = HeaderMap::new();
1021 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1022 let body = None;
1023
1024 self.client
1025 .request_json(
1026 Method::GET,
1027 &path,
1028 headers,
1029 query,
1030 body,
1031 )
1032 .await
1033 }
1034#[instrument(skip(self, params))]
1036 pub async fn get_misc_phoneinfo(&self, params: GetMiscPhoneinfoParams) -> Result<Value> {
1037 let mut path = "/api/v1/misc/phoneinfo".to_string();
1038
1039 let mut query: Vec<(String, String)> = Vec::new();
1040 query.push(("phone".to_string(), params.phone_query.clone()));
1041 let query = if query.is_empty() { None } else { Some(query) };
1042
1043 let mut extra_headers = HeaderMap::new();
1044 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1045 let body = None;
1046
1047 self.client
1048 .request_json(
1049 Method::GET,
1050 &path,
1051 headers,
1052 query,
1053 body,
1054 )
1055 .await
1056 }
1057#[instrument(skip(self, params))]
1059 pub async fn get_misc_randomnumber(&self, params: GetMiscRandomnumberParams) -> Result<Value> {
1060 let mut path = "/api/v1/misc/randomnumber".to_string();
1061
1062 let mut query: Vec<(String, String)> = Vec::new();
1063 if let Some(value) = ¶ms.min_query {
1064 query.push(("min".to_string(), value.clone()));
1065 }
1066 if let Some(value) = ¶ms.max_query {
1067 query.push(("max".to_string(), value.clone()));
1068 }
1069 if let Some(value) = ¶ms.count_query {
1070 query.push(("count".to_string(), value.clone()));
1071 }
1072 if let Some(value) = ¶ms.allow_repeat_query {
1073 query.push(("allow_repeat".to_string(), value.clone()));
1074 }
1075 if let Some(value) = ¶ms.allow_decimal_query {
1076 query.push(("allow_decimal".to_string(), value.clone()));
1077 }
1078 if let Some(value) = ¶ms.decimal_places_query {
1079 query.push(("decimal_places".to_string(), value.clone()));
1080 }
1081 let query = if query.is_empty() { None } else { Some(query) };
1082
1083 let mut extra_headers = HeaderMap::new();
1084 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1085 let body = None;
1086
1087 self.client
1088 .request_json(
1089 Method::GET,
1090 &path,
1091 headers,
1092 query,
1093 body,
1094 )
1095 .await
1096 }
1097#[instrument(skip(self, params))]
1099 pub async fn get_misc_timestamp(&self, params: GetMiscTimestampParams) -> Result<Value> {
1100 let mut path = "/api/v1/misc/timestamp".to_string();
1101
1102 let mut query: Vec<(String, String)> = Vec::new();
1103 query.push(("ts".to_string(), params.ts_query.clone()));
1104 let query = if query.is_empty() { None } else { Some(query) };
1105
1106 let mut extra_headers = HeaderMap::new();
1107 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1108 let body = None;
1109
1110 self.client
1111 .request_json(
1112 Method::GET,
1113 &path,
1114 headers,
1115 query,
1116 body,
1117 )
1118 .await
1119 }
1120#[instrument(skip(self))]
1122 pub async fn get_misc_tracking_carriers(&self) -> Result<Value> {
1123 let mut path = "/api/v1/misc/tracking/carriers".to_string();
1124
1125 let mut query: Vec<(String, String)> = Vec::new();
1126 let query = if query.is_empty() { None } else { Some(query) };
1127
1128 let mut extra_headers = HeaderMap::new();
1129 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1130 let body = None;
1131
1132 self.client
1133 .request_json(
1134 Method::GET,
1135 &path,
1136 headers,
1137 query,
1138 body,
1139 )
1140 .await
1141 }
1142#[instrument(skip(self, params))]
1144 pub async fn get_misc_tracking_detect(&self, params: GetMiscTrackingDetectParams) -> Result<Value> {
1145 let mut path = "/api/v1/misc/tracking/detect".to_string();
1146
1147 let mut query: Vec<(String, String)> = Vec::new();
1148 query.push(("tracking_number".to_string(), params.tracking_number_query.clone()));
1149 let query = if query.is_empty() { None } else { Some(query) };
1150
1151 let mut extra_headers = HeaderMap::new();
1152 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1153 let body = None;
1154
1155 self.client
1156 .request_json(
1157 Method::GET,
1158 &path,
1159 headers,
1160 query,
1161 body,
1162 )
1163 .await
1164 }
1165#[instrument(skip(self, params))]
1167 pub async fn get_misc_tracking_query(&self, params: GetMiscTrackingQueryParams) -> Result<Value> {
1168 let mut path = "/api/v1/misc/tracking/query".to_string();
1169
1170 let mut query: Vec<(String, String)> = Vec::new();
1171 query.push(("tracking_number".to_string(), params.tracking_number_query.clone()));
1172 if let Some(value) = ¶ms.carrier_code_query {
1173 query.push(("carrier_code".to_string(), value.clone()));
1174 }
1175 let query = if query.is_empty() { None } else { Some(query) };
1176
1177 let mut extra_headers = HeaderMap::new();
1178 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1179 let body = None;
1180
1181 self.client
1182 .request_json(
1183 Method::GET,
1184 &path,
1185 headers,
1186 query,
1187 body,
1188 )
1189 .await
1190 }
1191#[instrument(skip(self, params))]
1193 pub async fn get_misc_weather(&self, params: GetMiscWeatherParams) -> Result<Value> {
1194 let mut path = "/api/v1/misc/weather".to_string();
1195
1196 let mut query: Vec<(String, String)> = Vec::new();
1197 if let Some(value) = ¶ms.city_query {
1198 query.push(("city".to_string(), value.clone()));
1199 }
1200 if let Some(value) = ¶ms.adcode_query {
1201 query.push(("adcode".to_string(), value.clone()));
1202 }
1203 if let Some(value) = ¶ms.extended_query {
1204 query.push(("extended".to_string(), value.clone()));
1205 }
1206 if let Some(value) = ¶ms.indices_query {
1207 query.push(("indices".to_string(), value.clone()));
1208 }
1209 if let Some(value) = ¶ms.forecast_query {
1210 query.push(("forecast".to_string(), value.clone()));
1211 }
1212 let query = if query.is_empty() { None } else { Some(query) };
1213
1214 let mut extra_headers = HeaderMap::new();
1215 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1216 let body = None;
1217
1218 self.client
1219 .request_json(
1220 Method::GET,
1221 &path,
1222 headers,
1223 query,
1224 body,
1225 )
1226 .await
1227 }
1228#[instrument(skip(self, params))]
1230 pub async fn get_misc_worldtime(&self, params: GetMiscWorldtimeParams) -> Result<Value> {
1231 let mut path = "/api/v1/misc/worldtime".to_string();
1232
1233 let mut query: Vec<(String, String)> = Vec::new();
1234 query.push(("city".to_string(), params.city_query.clone()));
1235 let query = if query.is_empty() { None } else { Some(query) };
1236
1237 let mut extra_headers = HeaderMap::new();
1238 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1239 let body = None;
1240
1241 self.client
1242 .request_json(
1243 Method::GET,
1244 &path,
1245 headers,
1246 query,
1247 body,
1248 )
1249 .await
1250 }
1251#[instrument(skip(self, params))]
1253 pub async fn post_misc_date_diff(&self, params: PostMiscDateDiffParams) -> Result<Value> {
1254 let mut path = "/api/v1/misc/date-diff".to_string();
1255
1256 let mut query: Vec<(String, String)> = Vec::new();
1257 let query = if query.is_empty() { None } else { Some(query) };
1258
1259 let mut extra_headers = HeaderMap::new();
1260 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1261 let body = params.body.clone();
1262
1263 self.client
1264 .request_json(
1265 Method::POST,
1266 &path,
1267 headers,
1268 query,
1269 body,
1270 )
1271 .await
1272 }
1273}
1274
1275#[derive(Debug, Clone)]
1276pub struct GetHistoryProgrammerParams {
1277 pub month_query: String,
1278 pub day_query: String,
1279}
1280
1281impl GetHistoryProgrammerParams {
1282 pub fn new(month_query: impl Into<String>, day_query: impl Into<String>) -> Self {
1283 Self {
1284 month_query: month_query.into(),
1285 day_query: day_query.into(),
1286 }
1287 }
1288}
1289
1290
1291#[derive(Debug, Clone)]
1292pub struct GetMiscHotboardParams {
1293 pub type_query: String,
1294}
1295
1296impl GetMiscHotboardParams {
1297 pub fn new(type_query: impl Into<String>) -> Self {
1298 Self {
1299 type_query: type_query.into(),
1300 }
1301 }
1302}
1303
1304#[derive(Debug, Clone)]
1305pub struct GetMiscPhoneinfoParams {
1306 pub phone_query: String,
1307}
1308
1309impl GetMiscPhoneinfoParams {
1310 pub fn new(phone_query: impl Into<String>) -> Self {
1311 Self {
1312 phone_query: phone_query.into(),
1313 }
1314 }
1315}
1316
1317#[derive(Debug, Clone)]
1318pub struct GetMiscRandomnumberParams {
1319 pub min_query: Option<String>,
1320 pub max_query: Option<String>,
1321 pub count_query: Option<String>,
1322 pub allow_repeat_query: Option<String>,
1323 pub allow_decimal_query: Option<String>,
1324 pub decimal_places_query: Option<String>,
1325}
1326
1327impl GetMiscRandomnumberParams {
1328 pub fn new() -> Self {
1329 Self {
1330 min_query: None,
1331 max_query: None,
1332 count_query: None,
1333 allow_repeat_query: None,
1334 allow_decimal_query: None,
1335 decimal_places_query: None,
1336 }
1337 }
1338 pub fn min_query(mut self, value: impl Into<String>) -> Self {
1339 self.min_query = Some(value.into());
1340 self
1341 }
1342 pub fn max_query(mut self, value: impl Into<String>) -> Self {
1343 self.max_query = Some(value.into());
1344 self
1345 }
1346 pub fn count_query(mut self, value: impl Into<String>) -> Self {
1347 self.count_query = Some(value.into());
1348 self
1349 }
1350 pub fn allow_repeat_query(mut self, value: impl Into<String>) -> Self {
1351 self.allow_repeat_query = Some(value.into());
1352 self
1353 }
1354 pub fn allow_decimal_query(mut self, value: impl Into<String>) -> Self {
1355 self.allow_decimal_query = Some(value.into());
1356 self
1357 }
1358 pub fn decimal_places_query(mut self, value: impl Into<String>) -> Self {
1359 self.decimal_places_query = Some(value.into());
1360 self
1361 }
1362}
1363
1364#[derive(Debug, Clone)]
1365pub struct GetMiscTimestampParams {
1366 pub ts_query: String,
1367}
1368
1369impl GetMiscTimestampParams {
1370 pub fn new(ts_query: impl Into<String>) -> Self {
1371 Self {
1372 ts_query: ts_query.into(),
1373 }
1374 }
1375}
1376
1377
1378#[derive(Debug, Clone)]
1379pub struct GetMiscTrackingDetectParams {
1380 pub tracking_number_query: String,
1381}
1382
1383impl GetMiscTrackingDetectParams {
1384 pub fn new(tracking_number_query: impl Into<String>) -> Self {
1385 Self {
1386 tracking_number_query: tracking_number_query.into(),
1387 }
1388 }
1389}
1390
1391#[derive(Debug, Clone)]
1392pub struct GetMiscTrackingQueryParams {
1393 pub tracking_number_query: String,
1394 pub carrier_code_query: Option<String>,
1395}
1396
1397impl GetMiscTrackingQueryParams {
1398 pub fn new(tracking_number_query: impl Into<String>) -> Self {
1399 Self {
1400 tracking_number_query: tracking_number_query.into(),
1401 carrier_code_query: None,
1402 }
1403 }
1404 pub fn carrier_code_query(mut self, value: impl Into<String>) -> Self {
1405 self.carrier_code_query = Some(value.into());
1406 self
1407 }
1408}
1409
1410#[derive(Debug, Clone)]
1411pub struct GetMiscWeatherParams {
1412 pub city_query: Option<String>,
1413 pub adcode_query: Option<String>,
1414 pub extended_query: Option<String>,
1415 pub indices_query: Option<String>,
1416 pub forecast_query: Option<String>,
1417}
1418
1419impl GetMiscWeatherParams {
1420 pub fn new() -> Self {
1421 Self {
1422 city_query: None,
1423 adcode_query: None,
1424 extended_query: None,
1425 indices_query: None,
1426 forecast_query: None,
1427 }
1428 }
1429 pub fn city_query(mut self, value: impl Into<String>) -> Self {
1430 self.city_query = Some(value.into());
1431 self
1432 }
1433 pub fn adcode_query(mut self, value: impl Into<String>) -> Self {
1434 self.adcode_query = Some(value.into());
1435 self
1436 }
1437 pub fn extended_query(mut self, value: impl Into<String>) -> Self {
1438 self.extended_query = Some(value.into());
1439 self
1440 }
1441 pub fn indices_query(mut self, value: impl Into<String>) -> Self {
1442 self.indices_query = Some(value.into());
1443 self
1444 }
1445 pub fn forecast_query(mut self, value: impl Into<String>) -> Self {
1446 self.forecast_query = Some(value.into());
1447 self
1448 }
1449}
1450
1451#[derive(Debug, Clone)]
1452pub struct GetMiscWorldtimeParams {
1453 pub city_query: String,
1454}
1455
1456impl GetMiscWorldtimeParams {
1457 pub fn new(city_query: impl Into<String>) -> Self {
1458 Self {
1459 city_query: city_query.into(),
1460 }
1461 }
1462}
1463
1464#[derive(Debug, Clone)]
1465pub struct PostMiscDateDiffParams {
1466 pub body: Option<Value>,
1467}
1468
1469impl PostMiscDateDiffParams {
1470 pub fn new() -> Self {
1471 Self {
1472 body: None,
1473 }
1474 }
1475 pub fn body(mut self, value: Value) -> Self {
1476 self.body = Some(value);
1477 self
1478 }
1479}
1480#[derive(Debug, Clone)]
1481pub struct NetworkService<'a> {
1482 pub(crate) client: &'a Client,
1483}
1484
1485impl<'a> NetworkService<'a> {
1486#[instrument(skip(self, params))]
1488 pub async fn get_network_dns(&self, params: GetNetworkDnsParams) -> Result<Value> {
1489 let mut path = "/api/v1/network/dns".to_string();
1490
1491 let mut query: Vec<(String, String)> = Vec::new();
1492 query.push(("domain".to_string(), params.domain_query.clone()));
1493 if let Some(value) = ¶ms.type_query {
1494 query.push(("type".to_string(), value.clone()));
1495 }
1496 let query = if query.is_empty() { None } else { Some(query) };
1497
1498 let mut extra_headers = HeaderMap::new();
1499 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1500 let body = None;
1501
1502 self.client
1503 .request_json(
1504 Method::GET,
1505 &path,
1506 headers,
1507 query,
1508 body,
1509 )
1510 .await
1511 }
1512#[instrument(skip(self, params))]
1514 pub async fn get_network_icp(&self, params: GetNetworkIcpParams) -> Result<Value> {
1515 let mut path = "/api/v1/network/icp".to_string();
1516
1517 let mut query: Vec<(String, String)> = Vec::new();
1518 query.push(("domain".to_string(), params.domain_query.clone()));
1519 let query = if query.is_empty() { None } else { Some(query) };
1520
1521 let mut extra_headers = HeaderMap::new();
1522 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1523 let body = None;
1524
1525 self.client
1526 .request_json(
1527 Method::GET,
1528 &path,
1529 headers,
1530 query,
1531 body,
1532 )
1533 .await
1534 }
1535#[instrument(skip(self, params))]
1537 pub async fn get_network_ipinfo(&self, params: GetNetworkIpinfoParams) -> Result<Value> {
1538 let mut path = "/api/v1/network/ipinfo".to_string();
1539
1540 let mut query: Vec<(String, String)> = Vec::new();
1541 query.push(("ip".to_string(), params.ip_query.clone()));
1542 if let Some(value) = ¶ms.source_query {
1543 query.push(("source".to_string(), value.clone()));
1544 }
1545 let query = if query.is_empty() { None } else { Some(query) };
1546
1547 let mut extra_headers = HeaderMap::new();
1548 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1549 let body = None;
1550
1551 self.client
1552 .request_json(
1553 Method::GET,
1554 &path,
1555 headers,
1556 query,
1557 body,
1558 )
1559 .await
1560 }
1561#[instrument(skip(self, params))]
1563 pub async fn get_network_myip(&self, params: GetNetworkMyipParams) -> Result<Value> {
1564 let mut path = "/api/v1/network/myip".to_string();
1565
1566 let mut query: Vec<(String, String)> = Vec::new();
1567 if let Some(value) = ¶ms.source_query {
1568 query.push(("source".to_string(), value.clone()));
1569 }
1570 let query = if query.is_empty() { None } else { Some(query) };
1571
1572 let mut extra_headers = HeaderMap::new();
1573 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1574 let body = None;
1575
1576 self.client
1577 .request_json(
1578 Method::GET,
1579 &path,
1580 headers,
1581 query,
1582 body,
1583 )
1584 .await
1585 }
1586#[instrument(skip(self, params))]
1588 pub async fn get_network_ping(&self, params: GetNetworkPingParams) -> Result<Value> {
1589 let mut path = "/api/v1/network/ping".to_string();
1590
1591 let mut query: Vec<(String, String)> = Vec::new();
1592 query.push(("host".to_string(), params.host_query.clone()));
1593 let query = if query.is_empty() { None } else { Some(query) };
1594
1595 let mut extra_headers = HeaderMap::new();
1596 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1597 let body = None;
1598
1599 self.client
1600 .request_json(
1601 Method::GET,
1602 &path,
1603 headers,
1604 query,
1605 body,
1606 )
1607 .await
1608 }
1609#[instrument(skip(self))]
1611 pub async fn get_network_pingmyip(&self) -> Result<Value> {
1612 let mut path = "/api/v1/network/pingmyip".to_string();
1613
1614 let mut query: Vec<(String, String)> = Vec::new();
1615 let query = if query.is_empty() { None } else { Some(query) };
1616
1617 let mut extra_headers = HeaderMap::new();
1618 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1619 let body = None;
1620
1621 self.client
1622 .request_json(
1623 Method::GET,
1624 &path,
1625 headers,
1626 query,
1627 body,
1628 )
1629 .await
1630 }
1631#[instrument(skip(self, params))]
1633 pub async fn get_network_portscan(&self, params: GetNetworkPortscanParams) -> Result<Value> {
1634 let mut path = "/api/v1/network/portscan".to_string();
1635
1636 let mut query: Vec<(String, String)> = Vec::new();
1637 query.push(("host".to_string(), params.host_query.clone()));
1638 query.push(("port".to_string(), params.port_query.clone()));
1639 if let Some(value) = ¶ms.protocol_query {
1640 query.push(("protocol".to_string(), value.clone()));
1641 }
1642 let query = if query.is_empty() { None } else { Some(query) };
1643
1644 let mut extra_headers = HeaderMap::new();
1645 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1646 let body = None;
1647
1648 self.client
1649 .request_json(
1650 Method::GET,
1651 &path,
1652 headers,
1653 query,
1654 body,
1655 )
1656 .await
1657 }
1658#[instrument(skip(self, params))]
1660 pub async fn get_network_urlstatus(&self, params: GetNetworkUrlstatusParams) -> Result<Value> {
1661 let mut path = "/api/v1/network/urlstatus".to_string();
1662
1663 let mut query: Vec<(String, String)> = Vec::new();
1664 query.push(("url".to_string(), params.url_query.clone()));
1665 let query = if query.is_empty() { None } else { Some(query) };
1666
1667 let mut extra_headers = HeaderMap::new();
1668 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1669 let body = None;
1670
1671 self.client
1672 .request_json(
1673 Method::GET,
1674 &path,
1675 headers,
1676 query,
1677 body,
1678 )
1679 .await
1680 }
1681#[instrument(skip(self, params))]
1683 pub async fn get_network_whois(&self, params: GetNetworkWhoisParams) -> Result<Value> {
1684 let mut path = "/api/v1/network/whois".to_string();
1685
1686 let mut query: Vec<(String, String)> = Vec::new();
1687 query.push(("domain".to_string(), params.domain_query.clone()));
1688 if let Some(value) = ¶ms.format_query {
1689 query.push(("format".to_string(), value.clone()));
1690 }
1691 let query = if query.is_empty() { None } else { Some(query) };
1692
1693 let mut extra_headers = HeaderMap::new();
1694 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1695 let body = None;
1696
1697 self.client
1698 .request_json(
1699 Method::GET,
1700 &path,
1701 headers,
1702 query,
1703 body,
1704 )
1705 .await
1706 }
1707#[instrument(skip(self, params))]
1709 pub async fn get_network_wxdomain(&self, params: GetNetworkWxdomainParams) -> Result<Value> {
1710 let mut path = "/api/v1/network/wxdomain".to_string();
1711
1712 let mut query: Vec<(String, String)> = Vec::new();
1713 query.push(("domain".to_string(), params.domain_query.clone()));
1714 let query = if query.is_empty() { None } else { Some(query) };
1715
1716 let mut extra_headers = HeaderMap::new();
1717 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1718 let body = None;
1719
1720 self.client
1721 .request_json(
1722 Method::GET,
1723 &path,
1724 headers,
1725 query,
1726 body,
1727 )
1728 .await
1729 }
1730}
1731
1732#[derive(Debug, Clone)]
1733pub struct GetNetworkDnsParams {
1734 pub domain_query: String,
1735 pub type_query: Option<String>,
1736}
1737
1738impl GetNetworkDnsParams {
1739 pub fn new(domain_query: impl Into<String>) -> Self {
1740 Self {
1741 domain_query: domain_query.into(),
1742 type_query: None,
1743 }
1744 }
1745 pub fn type_query(mut self, value: impl Into<String>) -> Self {
1746 self.type_query = Some(value.into());
1747 self
1748 }
1749}
1750
1751#[derive(Debug, Clone)]
1752pub struct GetNetworkIcpParams {
1753 pub domain_query: String,
1754}
1755
1756impl GetNetworkIcpParams {
1757 pub fn new(domain_query: impl Into<String>) -> Self {
1758 Self {
1759 domain_query: domain_query.into(),
1760 }
1761 }
1762}
1763
1764#[derive(Debug, Clone)]
1765pub struct GetNetworkIpinfoParams {
1766 pub ip_query: String,
1767 pub source_query: Option<String>,
1768}
1769
1770impl GetNetworkIpinfoParams {
1771 pub fn new(ip_query: impl Into<String>) -> Self {
1772 Self {
1773 ip_query: ip_query.into(),
1774 source_query: None,
1775 }
1776 }
1777 pub fn source_query(mut self, value: impl Into<String>) -> Self {
1778 self.source_query = Some(value.into());
1779 self
1780 }
1781}
1782
1783#[derive(Debug, Clone)]
1784pub struct GetNetworkMyipParams {
1785 pub source_query: Option<String>,
1786}
1787
1788impl GetNetworkMyipParams {
1789 pub fn new() -> Self {
1790 Self {
1791 source_query: None,
1792 }
1793 }
1794 pub fn source_query(mut self, value: impl Into<String>) -> Self {
1795 self.source_query = Some(value.into());
1796 self
1797 }
1798}
1799
1800#[derive(Debug, Clone)]
1801pub struct GetNetworkPingParams {
1802 pub host_query: String,
1803}
1804
1805impl GetNetworkPingParams {
1806 pub fn new(host_query: impl Into<String>) -> Self {
1807 Self {
1808 host_query: host_query.into(),
1809 }
1810 }
1811}
1812
1813
1814#[derive(Debug, Clone)]
1815pub struct GetNetworkPortscanParams {
1816 pub host_query: String,
1817 pub port_query: String,
1818 pub protocol_query: Option<String>,
1819}
1820
1821impl GetNetworkPortscanParams {
1822 pub fn new(host_query: impl Into<String>, port_query: impl Into<String>) -> Self {
1823 Self {
1824 host_query: host_query.into(),
1825 port_query: port_query.into(),
1826 protocol_query: None,
1827 }
1828 }
1829 pub fn protocol_query(mut self, value: impl Into<String>) -> Self {
1830 self.protocol_query = Some(value.into());
1831 self
1832 }
1833}
1834
1835#[derive(Debug, Clone)]
1836pub struct GetNetworkUrlstatusParams {
1837 pub url_query: String,
1838}
1839
1840impl GetNetworkUrlstatusParams {
1841 pub fn new(url_query: impl Into<String>) -> Self {
1842 Self {
1843 url_query: url_query.into(),
1844 }
1845 }
1846}
1847
1848#[derive(Debug, Clone)]
1849pub struct GetNetworkWhoisParams {
1850 pub domain_query: String,
1851 pub format_query: Option<String>,
1852}
1853
1854impl GetNetworkWhoisParams {
1855 pub fn new(domain_query: impl Into<String>) -> Self {
1856 Self {
1857 domain_query: domain_query.into(),
1858 format_query: None,
1859 }
1860 }
1861 pub fn format_query(mut self, value: impl Into<String>) -> Self {
1862 self.format_query = Some(value.into());
1863 self
1864 }
1865}
1866
1867#[derive(Debug, Clone)]
1868pub struct GetNetworkWxdomainParams {
1869 pub domain_query: String,
1870}
1871
1872impl GetNetworkWxdomainParams {
1873 pub fn new(domain_query: impl Into<String>) -> Self {
1874 Self {
1875 domain_query: domain_query.into(),
1876 }
1877 }
1878}
1879#[derive(Debug, Clone)]
1880pub struct PoemService<'a> {
1881 pub(crate) client: &'a Client,
1882}
1883
1884impl<'a> PoemService<'a> {
1885#[instrument(skip(self))]
1887 pub async fn get_saying(&self) -> Result<Value> {
1888 let mut path = "/api/v1/saying".to_string();
1889
1890 let mut query: Vec<(String, String)> = Vec::new();
1891 let query = if query.is_empty() { None } else { Some(query) };
1892
1893 let mut extra_headers = HeaderMap::new();
1894 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1895 let body = None;
1896
1897 self.client
1898 .request_json(
1899 Method::GET,
1900 &path,
1901 headers,
1902 query,
1903 body,
1904 )
1905 .await
1906 }
1907}
1908
1909#[derive(Debug, Clone)]
1910pub struct RandomService<'a> {
1911 pub(crate) client: &'a Client,
1912}
1913
1914impl<'a> RandomService<'a> {
1915#[instrument(skip(self, params))]
1917 pub async fn get_answerbook_ask(&self, params: GetAnswerbookAskParams) -> Result<Value> {
1918 let mut path = "/api/v1/answerbook/ask".to_string();
1919
1920 let mut query: Vec<(String, String)> = Vec::new();
1921 query.push(("question".to_string(), params.question_query.clone()));
1922 let query = if query.is_empty() { None } else { Some(query) };
1923
1924 let mut extra_headers = HeaderMap::new();
1925 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1926 let body = None;
1927
1928 self.client
1929 .request_json(
1930 Method::GET,
1931 &path,
1932 headers,
1933 query,
1934 body,
1935 )
1936 .await
1937 }
1938#[instrument(skip(self, params))]
1940 pub async fn get_random_image(&self, params: GetRandomImageParams) -> Result<Value> {
1941 let mut path = "/api/v1/random/image".to_string();
1942
1943 let mut query: Vec<(String, String)> = Vec::new();
1944 if let Some(value) = ¶ms.category_query {
1945 query.push(("category".to_string(), value.clone()));
1946 }
1947 if let Some(value) = ¶ms.type_query {
1948 query.push(("type".to_string(), value.clone()));
1949 }
1950 let query = if query.is_empty() { None } else { Some(query) };
1951
1952 let mut extra_headers = HeaderMap::new();
1953 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1954 let body = None;
1955
1956 self.client
1957 .request_json(
1958 Method::GET,
1959 &path,
1960 headers,
1961 query,
1962 body,
1963 )
1964 .await
1965 }
1966#[instrument(skip(self, params))]
1968 pub async fn get_random_string(&self, params: GetRandomStringParams) -> Result<Value> {
1969 let mut path = "/api/v1/random/string".to_string();
1970
1971 let mut query: Vec<(String, String)> = Vec::new();
1972 if let Some(value) = ¶ms.length_query {
1973 query.push(("length".to_string(), value.clone()));
1974 }
1975 if let Some(value) = ¶ms.type_query {
1976 query.push(("type".to_string(), value.clone()));
1977 }
1978 let query = if query.is_empty() { None } else { Some(query) };
1979
1980 let mut extra_headers = HeaderMap::new();
1981 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
1982 let body = None;
1983
1984 self.client
1985 .request_json(
1986 Method::GET,
1987 &path,
1988 headers,
1989 query,
1990 body,
1991 )
1992 .await
1993 }
1994#[instrument(skip(self, params))]
1996 pub async fn post_answerbook_ask(&self, params: PostAnswerbookAskParams) -> Result<Value> {
1997 let mut path = "/api/v1/answerbook/ask".to_string();
1998
1999 let mut query: Vec<(String, String)> = Vec::new();
2000 let query = if query.is_empty() { None } else { Some(query) };
2001
2002 let mut extra_headers = HeaderMap::new();
2003 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2004 let body = params.body.clone();
2005
2006 self.client
2007 .request_json(
2008 Method::POST,
2009 &path,
2010 headers,
2011 query,
2012 body,
2013 )
2014 .await
2015 }
2016}
2017
2018#[derive(Debug, Clone)]
2019pub struct GetAnswerbookAskParams {
2020 pub question_query: String,
2021}
2022
2023impl GetAnswerbookAskParams {
2024 pub fn new(question_query: impl Into<String>) -> Self {
2025 Self {
2026 question_query: question_query.into(),
2027 }
2028 }
2029}
2030
2031#[derive(Debug, Clone)]
2032pub struct GetRandomImageParams {
2033 pub category_query: Option<String>,
2034 pub type_query: Option<String>,
2035}
2036
2037impl GetRandomImageParams {
2038 pub fn new() -> Self {
2039 Self {
2040 category_query: None,
2041 type_query: None,
2042 }
2043 }
2044 pub fn category_query(mut self, value: impl Into<String>) -> Self {
2045 self.category_query = Some(value.into());
2046 self
2047 }
2048 pub fn type_query(mut self, value: impl Into<String>) -> Self {
2049 self.type_query = Some(value.into());
2050 self
2051 }
2052}
2053
2054#[derive(Debug, Clone)]
2055pub struct GetRandomStringParams {
2056 pub length_query: Option<String>,
2057 pub type_query: Option<String>,
2058}
2059
2060impl GetRandomStringParams {
2061 pub fn new() -> Self {
2062 Self {
2063 length_query: None,
2064 type_query: None,
2065 }
2066 }
2067 pub fn length_query(mut self, value: impl Into<String>) -> Self {
2068 self.length_query = Some(value.into());
2069 self
2070 }
2071 pub fn type_query(mut self, value: impl Into<String>) -> Self {
2072 self.type_query = Some(value.into());
2073 self
2074 }
2075}
2076
2077#[derive(Debug, Clone)]
2078pub struct PostAnswerbookAskParams {
2079 pub body: Option<Value>,
2080}
2081
2082impl PostAnswerbookAskParams {
2083 pub fn new() -> Self {
2084 Self {
2085 body: None,
2086 }
2087 }
2088 pub fn body(mut self, value: Value) -> Self {
2089 self.body = Some(value);
2090 self
2091 }
2092}
2093#[derive(Debug, Clone)]
2094pub struct SocialService<'a> {
2095 pub(crate) client: &'a Client,
2096}
2097
2098impl<'a> SocialService<'a> {
2099#[instrument(skip(self, params))]
2101 pub async fn get_github_repo(&self, params: GetGithubRepoParams) -> Result<Value> {
2102 let mut path = "/api/v1/github/repo".to_string();
2103
2104 let mut query: Vec<(String, String)> = Vec::new();
2105 query.push(("repo".to_string(), params.repo_query.clone()));
2106 let query = if query.is_empty() { None } else { Some(query) };
2107
2108 let mut extra_headers = HeaderMap::new();
2109 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2110 let body = None;
2111
2112 self.client
2113 .request_json(
2114 Method::GET,
2115 &path,
2116 headers,
2117 query,
2118 body,
2119 )
2120 .await
2121 }
2122#[instrument(skip(self, params))]
2124 pub async fn get_social_bilibili_archives(&self, params: GetSocialBilibiliArchivesParams) -> Result<Value> {
2125 let mut path = "/api/v1/social/bilibili/archives".to_string();
2126
2127 let mut query: Vec<(String, String)> = Vec::new();
2128 query.push(("mid".to_string(), params.mid_query.clone()));
2129 if let Some(value) = ¶ms.keywords_query {
2130 query.push(("keywords".to_string(), value.clone()));
2131 }
2132 if let Some(value) = ¶ms.orderby_query {
2133 query.push(("orderby".to_string(), value.clone()));
2134 }
2135 if let Some(value) = ¶ms.ps_query {
2136 query.push(("ps".to_string(), value.clone()));
2137 }
2138 if let Some(value) = ¶ms.pn_query {
2139 query.push(("pn".to_string(), value.clone()));
2140 }
2141 let query = if query.is_empty() { None } else { Some(query) };
2142
2143 let mut extra_headers = HeaderMap::new();
2144 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2145 let body = None;
2146
2147 self.client
2148 .request_json(
2149 Method::GET,
2150 &path,
2151 headers,
2152 query,
2153 body,
2154 )
2155 .await
2156 }
2157#[instrument(skip(self, params))]
2159 pub async fn get_social_bilibili_liveroom(&self, params: GetSocialBilibiliLiveroomParams) -> Result<Value> {
2160 let mut path = "/api/v1/social/bilibili/liveroom".to_string();
2161
2162 let mut query: Vec<(String, String)> = Vec::new();
2163 if let Some(value) = ¶ms.mid_query {
2164 query.push(("mid".to_string(), value.clone()));
2165 }
2166 if let Some(value) = ¶ms.room_id_query {
2167 query.push(("room_id".to_string(), value.clone()));
2168 }
2169 let query = if query.is_empty() { None } else { Some(query) };
2170
2171 let mut extra_headers = HeaderMap::new();
2172 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2173 let body = None;
2174
2175 self.client
2176 .request_json(
2177 Method::GET,
2178 &path,
2179 headers,
2180 query,
2181 body,
2182 )
2183 .await
2184 }
2185#[instrument(skip(self, params))]
2187 pub async fn get_social_bilibili_replies(&self, params: GetSocialBilibiliRepliesParams) -> Result<Value> {
2188 let mut path = "/api/v1/social/bilibili/replies".to_string();
2189
2190 let mut query: Vec<(String, String)> = Vec::new();
2191 query.push(("oid".to_string(), params.oid_query.clone()));
2192 if let Some(value) = ¶ms.sort_query {
2193 query.push(("sort".to_string(), value.clone()));
2194 }
2195 if let Some(value) = ¶ms.ps_query {
2196 query.push(("ps".to_string(), value.clone()));
2197 }
2198 if let Some(value) = ¶ms.pn_query {
2199 query.push(("pn".to_string(), value.clone()));
2200 }
2201 let query = if query.is_empty() { None } else { Some(query) };
2202
2203 let mut extra_headers = HeaderMap::new();
2204 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2205 let body = None;
2206
2207 self.client
2208 .request_json(
2209 Method::GET,
2210 &path,
2211 headers,
2212 query,
2213 body,
2214 )
2215 .await
2216 }
2217#[instrument(skip(self, params))]
2219 pub async fn get_social_bilibili_userinfo(&self, params: GetSocialBilibiliUserinfoParams) -> Result<Value> {
2220 let mut path = "/api/v1/social/bilibili/userinfo".to_string();
2221
2222 let mut query: Vec<(String, String)> = Vec::new();
2223 query.push(("uid".to_string(), params.uid_query.clone()));
2224 let query = if query.is_empty() { None } else { Some(query) };
2225
2226 let mut extra_headers = HeaderMap::new();
2227 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2228 let body = None;
2229
2230 self.client
2231 .request_json(
2232 Method::GET,
2233 &path,
2234 headers,
2235 query,
2236 body,
2237 )
2238 .await
2239 }
2240#[instrument(skip(self, params))]
2242 pub async fn get_social_bilibili_videoinfo(&self, params: GetSocialBilibiliVideoinfoParams) -> Result<Value> {
2243 let mut path = "/api/v1/social/bilibili/videoinfo".to_string();
2244
2245 let mut query: Vec<(String, String)> = Vec::new();
2246 if let Some(value) = ¶ms.aid_query {
2247 query.push(("aid".to_string(), value.clone()));
2248 }
2249 if let Some(value) = ¶ms.bvid_query {
2250 query.push(("bvid".to_string(), value.clone()));
2251 }
2252 let query = if query.is_empty() { None } else { Some(query) };
2253
2254 let mut extra_headers = HeaderMap::new();
2255 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2256 let body = None;
2257
2258 self.client
2259 .request_json(
2260 Method::GET,
2261 &path,
2262 headers,
2263 query,
2264 body,
2265 )
2266 .await
2267 }
2268#[instrument(skip(self, params))]
2270 pub async fn get_social_qq_groupinfo(&self, params: GetSocialQqGroupinfoParams) -> Result<Value> {
2271 let mut path = "/api/v1/social/qq/groupinfo".to_string();
2272
2273 let mut query: Vec<(String, String)> = Vec::new();
2274 query.push(("group_id".to_string(), params.group_id_query.clone()));
2275 let query = if query.is_empty() { None } else { Some(query) };
2276
2277 let mut extra_headers = HeaderMap::new();
2278 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2279 let body = None;
2280
2281 self.client
2282 .request_json(
2283 Method::GET,
2284 &path,
2285 headers,
2286 query,
2287 body,
2288 )
2289 .await
2290 }
2291#[instrument(skip(self, params))]
2293 pub async fn get_social_qq_userinfo(&self, params: GetSocialQqUserinfoParams) -> Result<Value> {
2294 let mut path = "/api/v1/social/qq/userinfo".to_string();
2295
2296 let mut query: Vec<(String, String)> = Vec::new();
2297 query.push(("qq".to_string(), params.qq_query.clone()));
2298 let query = if query.is_empty() { None } else { Some(query) };
2299
2300 let mut extra_headers = HeaderMap::new();
2301 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2302 let body = None;
2303
2304 self.client
2305 .request_json(
2306 Method::GET,
2307 &path,
2308 headers,
2309 query,
2310 body,
2311 )
2312 .await
2313 }
2314}
2315
2316#[derive(Debug, Clone)]
2317pub struct GetGithubRepoParams {
2318 pub repo_query: String,
2319}
2320
2321impl GetGithubRepoParams {
2322 pub fn new(repo_query: impl Into<String>) -> Self {
2323 Self {
2324 repo_query: repo_query.into(),
2325 }
2326 }
2327}
2328
2329#[derive(Debug, Clone)]
2330pub struct GetSocialBilibiliArchivesParams {
2331 pub mid_query: String,
2332 pub keywords_query: Option<String>,
2333 pub orderby_query: Option<String>,
2334 pub ps_query: Option<String>,
2335 pub pn_query: Option<String>,
2336}
2337
2338impl GetSocialBilibiliArchivesParams {
2339 pub fn new(mid_query: impl Into<String>) -> Self {
2340 Self {
2341 mid_query: mid_query.into(),
2342 keywords_query: None,
2343 orderby_query: None,
2344 ps_query: None,
2345 pn_query: None,
2346 }
2347 }
2348 pub fn keywords_query(mut self, value: impl Into<String>) -> Self {
2349 self.keywords_query = Some(value.into());
2350 self
2351 }
2352 pub fn orderby_query(mut self, value: impl Into<String>) -> Self {
2353 self.orderby_query = Some(value.into());
2354 self
2355 }
2356 pub fn ps_query(mut self, value: impl Into<String>) -> Self {
2357 self.ps_query = Some(value.into());
2358 self
2359 }
2360 pub fn pn_query(mut self, value: impl Into<String>) -> Self {
2361 self.pn_query = Some(value.into());
2362 self
2363 }
2364}
2365
2366#[derive(Debug, Clone)]
2367pub struct GetSocialBilibiliLiveroomParams {
2368 pub mid_query: Option<String>,
2369 pub room_id_query: Option<String>,
2370}
2371
2372impl GetSocialBilibiliLiveroomParams {
2373 pub fn new() -> Self {
2374 Self {
2375 mid_query: None,
2376 room_id_query: None,
2377 }
2378 }
2379 pub fn mid_query(mut self, value: impl Into<String>) -> Self {
2380 self.mid_query = Some(value.into());
2381 self
2382 }
2383 pub fn room_id_query(mut self, value: impl Into<String>) -> Self {
2384 self.room_id_query = Some(value.into());
2385 self
2386 }
2387}
2388
2389#[derive(Debug, Clone)]
2390pub struct GetSocialBilibiliRepliesParams {
2391 pub oid_query: String,
2392 pub sort_query: Option<String>,
2393 pub ps_query: Option<String>,
2394 pub pn_query: Option<String>,
2395}
2396
2397impl GetSocialBilibiliRepliesParams {
2398 pub fn new(oid_query: impl Into<String>) -> Self {
2399 Self {
2400 oid_query: oid_query.into(),
2401 sort_query: None,
2402 ps_query: None,
2403 pn_query: None,
2404 }
2405 }
2406 pub fn sort_query(mut self, value: impl Into<String>) -> Self {
2407 self.sort_query = Some(value.into());
2408 self
2409 }
2410 pub fn ps_query(mut self, value: impl Into<String>) -> Self {
2411 self.ps_query = Some(value.into());
2412 self
2413 }
2414 pub fn pn_query(mut self, value: impl Into<String>) -> Self {
2415 self.pn_query = Some(value.into());
2416 self
2417 }
2418}
2419
2420#[derive(Debug, Clone)]
2421pub struct GetSocialBilibiliUserinfoParams {
2422 pub uid_query: String,
2423}
2424
2425impl GetSocialBilibiliUserinfoParams {
2426 pub fn new(uid_query: impl Into<String>) -> Self {
2427 Self {
2428 uid_query: uid_query.into(),
2429 }
2430 }
2431}
2432
2433#[derive(Debug, Clone)]
2434pub struct GetSocialBilibiliVideoinfoParams {
2435 pub aid_query: Option<String>,
2436 pub bvid_query: Option<String>,
2437}
2438
2439impl GetSocialBilibiliVideoinfoParams {
2440 pub fn new() -> Self {
2441 Self {
2442 aid_query: None,
2443 bvid_query: None,
2444 }
2445 }
2446 pub fn aid_query(mut self, value: impl Into<String>) -> Self {
2447 self.aid_query = Some(value.into());
2448 self
2449 }
2450 pub fn bvid_query(mut self, value: impl Into<String>) -> Self {
2451 self.bvid_query = Some(value.into());
2452 self
2453 }
2454}
2455
2456#[derive(Debug, Clone)]
2457pub struct GetSocialQqGroupinfoParams {
2458 pub group_id_query: String,
2459}
2460
2461impl GetSocialQqGroupinfoParams {
2462 pub fn new(group_id_query: impl Into<String>) -> Self {
2463 Self {
2464 group_id_query: group_id_query.into(),
2465 }
2466 }
2467}
2468
2469#[derive(Debug, Clone)]
2470pub struct GetSocialQqUserinfoParams {
2471 pub qq_query: String,
2472}
2473
2474impl GetSocialQqUserinfoParams {
2475 pub fn new(qq_query: impl Into<String>) -> Self {
2476 Self {
2477 qq_query: qq_query.into(),
2478 }
2479 }
2480}
2481#[derive(Debug, Clone)]
2482pub struct StatusService<'a> {
2483 pub(crate) client: &'a Client,
2484}
2485
2486impl<'a> StatusService<'a> {
2487#[instrument(skip(self, params))]
2489 pub async fn get_status_ratelimit(&self, params: GetStatusRatelimitParams) -> Result<Value> {
2490 let mut path = "/api/v1/status/ratelimit".to_string();
2491
2492 let mut query: Vec<(String, String)> = Vec::new();
2493 let query = if query.is_empty() { None } else { Some(query) };
2494
2495 let mut extra_headers = HeaderMap::new();
2496 extra_headers.insert(
2497 "Authorization",
2498 HeaderValue::from_str(¶ms.authorization_header).map_err(|_| Error::InvalidHeader { name: "Authorization".into() })?,
2499 );
2500 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2501 let body = None;
2502
2503 self.client
2504 .request_json(
2505 Method::GET,
2506 &path,
2507 headers,
2508 query,
2509 body,
2510 )
2511 .await
2512 }
2513#[instrument(skip(self, params))]
2515 pub async fn get_status_usage(&self, params: GetStatusUsageParams) -> Result<Value> {
2516 let mut path = "/api/v1/status/usage".to_string();
2517
2518 let mut query: Vec<(String, String)> = Vec::new();
2519 if let Some(value) = ¶ms.path_query {
2520 query.push(("path".to_string(), value.clone()));
2521 }
2522 let query = if query.is_empty() { None } else { Some(query) };
2523
2524 let mut extra_headers = HeaderMap::new();
2525 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2526 let body = None;
2527
2528 self.client
2529 .request_json(
2530 Method::GET,
2531 &path,
2532 headers,
2533 query,
2534 body,
2535 )
2536 .await
2537 }
2538}
2539
2540#[derive(Debug, Clone)]
2541pub struct GetStatusRatelimitParams {
2542 pub authorization_header: String,
2543}
2544
2545impl GetStatusRatelimitParams {
2546 pub fn new(authorization_header: impl Into<String>) -> Self {
2547 Self {
2548 authorization_header: authorization_header.into(),
2549 }
2550 }
2551}
2552
2553#[derive(Debug, Clone)]
2554pub struct GetStatusUsageParams {
2555 pub path_query: Option<String>,
2556}
2557
2558impl GetStatusUsageParams {
2559 pub fn new() -> Self {
2560 Self {
2561 path_query: None,
2562 }
2563 }
2564 pub fn path_query(mut self, value: impl Into<String>) -> Self {
2565 self.path_query = Some(value.into());
2566 self
2567 }
2568}
2569#[derive(Debug, Clone)]
2570pub struct TextService<'a> {
2571 pub(crate) client: &'a Client,
2572}
2573
2574impl<'a> TextService<'a> {
2575#[instrument(skip(self, params))]
2577 pub async fn get_text_md_5(&self, params: GetTextMd5Params) -> Result<Value> {
2578 let mut path = "/api/v1/text/md5".to_string();
2579
2580 let mut query: Vec<(String, String)> = Vec::new();
2581 query.push(("text".to_string(), params.text_query.clone()));
2582 let query = if query.is_empty() { None } else { Some(query) };
2583
2584 let mut extra_headers = HeaderMap::new();
2585 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2586 let body = None;
2587
2588 self.client
2589 .request_json(
2590 Method::GET,
2591 &path,
2592 headers,
2593 query,
2594 body,
2595 )
2596 .await
2597 }
2598#[instrument(skip(self, params))]
2600 pub async fn post_text_aes_decrypt(&self, params: PostTextAesDecryptParams) -> Result<Value> {
2601 let mut path = "/api/v1/text/aes/decrypt".to_string();
2602
2603 let mut query: Vec<(String, String)> = Vec::new();
2604 let query = if query.is_empty() { None } else { Some(query) };
2605
2606 let mut extra_headers = HeaderMap::new();
2607 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2608 let body = params.body.clone();
2609
2610 self.client
2611 .request_json(
2612 Method::POST,
2613 &path,
2614 headers,
2615 query,
2616 body,
2617 )
2618 .await
2619 }
2620#[instrument(skip(self, params))]
2622 pub async fn post_text_aes_decrypt_advanced(&self, params: PostTextAesDecryptAdvancedParams) -> Result<Value> {
2623 let mut path = "/api/v1/text/aes/decrypt-advanced".to_string();
2624
2625 let mut query: Vec<(String, String)> = Vec::new();
2626 let query = if query.is_empty() { None } else { Some(query) };
2627
2628 let mut extra_headers = HeaderMap::new();
2629 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2630 let body = params.body.clone();
2631
2632 self.client
2633 .request_json(
2634 Method::POST,
2635 &path,
2636 headers,
2637 query,
2638 body,
2639 )
2640 .await
2641 }
2642#[instrument(skip(self, params))]
2644 pub async fn post_text_aes_encrypt(&self, params: PostTextAesEncryptParams) -> Result<Value> {
2645 let mut path = "/api/v1/text/aes/encrypt".to_string();
2646
2647 let mut query: Vec<(String, String)> = Vec::new();
2648 let query = if query.is_empty() { None } else { Some(query) };
2649
2650 let mut extra_headers = HeaderMap::new();
2651 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2652 let body = params.body.clone();
2653
2654 self.client
2655 .request_json(
2656 Method::POST,
2657 &path,
2658 headers,
2659 query,
2660 body,
2661 )
2662 .await
2663 }
2664#[instrument(skip(self, params))]
2666 pub async fn post_text_aes_encrypt_advanced(&self, params: PostTextAesEncryptAdvancedParams) -> Result<Value> {
2667 let mut path = "/api/v1/text/aes/encrypt-advanced".to_string();
2668
2669 let mut query: Vec<(String, String)> = Vec::new();
2670 let query = if query.is_empty() { None } else { Some(query) };
2671
2672 let mut extra_headers = HeaderMap::new();
2673 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2674 let body = params.body.clone();
2675
2676 self.client
2677 .request_json(
2678 Method::POST,
2679 &path,
2680 headers,
2681 query,
2682 body,
2683 )
2684 .await
2685 }
2686#[instrument(skip(self, params))]
2688 pub async fn post_text_analyze(&self, params: PostTextAnalyzeParams) -> Result<Value> {
2689 let mut path = "/api/v1/text/analyze".to_string();
2690
2691 let mut query: Vec<(String, String)> = Vec::new();
2692 let query = if query.is_empty() { None } else { Some(query) };
2693
2694 let mut extra_headers = HeaderMap::new();
2695 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2696 let body = params.body.clone();
2697
2698 self.client
2699 .request_json(
2700 Method::POST,
2701 &path,
2702 headers,
2703 query,
2704 body,
2705 )
2706 .await
2707 }
2708#[instrument(skip(self, params))]
2710 pub async fn post_text_base_64_decode(&self, params: PostTextBase64DecodeParams) -> Result<Value> {
2711 let mut path = "/api/v1/text/base64/decode".to_string();
2712
2713 let mut query: Vec<(String, String)> = Vec::new();
2714 let query = if query.is_empty() { None } else { Some(query) };
2715
2716 let mut extra_headers = HeaderMap::new();
2717 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2718 let body = params.body.clone();
2719
2720 self.client
2721 .request_json(
2722 Method::POST,
2723 &path,
2724 headers,
2725 query,
2726 body,
2727 )
2728 .await
2729 }
2730#[instrument(skip(self, params))]
2732 pub async fn post_text_base_64_encode(&self, params: PostTextBase64EncodeParams) -> Result<Value> {
2733 let mut path = "/api/v1/text/base64/encode".to_string();
2734
2735 let mut query: Vec<(String, String)> = Vec::new();
2736 let query = if query.is_empty() { None } else { Some(query) };
2737
2738 let mut extra_headers = HeaderMap::new();
2739 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2740 let body = params.body.clone();
2741
2742 self.client
2743 .request_json(
2744 Method::POST,
2745 &path,
2746 headers,
2747 query,
2748 body,
2749 )
2750 .await
2751 }
2752#[instrument(skip(self, params))]
2754 pub async fn post_text_convert(&self, params: PostTextConvertParams) -> Result<Value> {
2755 let mut path = "/api/v1/text/convert".to_string();
2756
2757 let mut query: Vec<(String, String)> = Vec::new();
2758 let query = if query.is_empty() { None } else { Some(query) };
2759
2760 let mut extra_headers = HeaderMap::new();
2761 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2762 let body = params.body.clone();
2763
2764 self.client
2765 .request_json(
2766 Method::POST,
2767 &path,
2768 headers,
2769 query,
2770 body,
2771 )
2772 .await
2773 }
2774#[instrument(skip(self, params))]
2776 pub async fn post_text_md_5(&self, params: PostTextMd5Params) -> Result<Value> {
2777 let mut path = "/api/v1/text/md5".to_string();
2778
2779 let mut query: Vec<(String, String)> = Vec::new();
2780 let query = if query.is_empty() { None } else { Some(query) };
2781
2782 let mut extra_headers = HeaderMap::new();
2783 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2784 let body = params.body.clone();
2785
2786 self.client
2787 .request_json(
2788 Method::POST,
2789 &path,
2790 headers,
2791 query,
2792 body,
2793 )
2794 .await
2795 }
2796#[instrument(skip(self, params))]
2798 pub async fn post_text_md_5_verify(&self, params: PostTextMd5VerifyParams) -> Result<Value> {
2799 let mut path = "/api/v1/text/md5/verify".to_string();
2800
2801 let mut query: Vec<(String, String)> = Vec::new();
2802 let query = if query.is_empty() { None } else { Some(query) };
2803
2804 let mut extra_headers = HeaderMap::new();
2805 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
2806 let body = params.body.clone();
2807
2808 self.client
2809 .request_json(
2810 Method::POST,
2811 &path,
2812 headers,
2813 query,
2814 body,
2815 )
2816 .await
2817 }
2818}
2819
2820#[derive(Debug, Clone)]
2821pub struct GetTextMd5Params {
2822 pub text_query: String,
2823}
2824
2825impl GetTextMd5Params {
2826 pub fn new(text_query: impl Into<String>) -> Self {
2827 Self {
2828 text_query: text_query.into(),
2829 }
2830 }
2831}
2832
2833#[derive(Debug, Clone)]
2834pub struct PostTextAesDecryptParams {
2835 pub body: Option<Value>,
2836}
2837
2838impl PostTextAesDecryptParams {
2839 pub fn new() -> Self {
2840 Self {
2841 body: None,
2842 }
2843 }
2844 pub fn body(mut self, value: Value) -> Self {
2845 self.body = Some(value);
2846 self
2847 }
2848}
2849
2850#[derive(Debug, Clone)]
2851pub struct PostTextAesDecryptAdvancedParams {
2852 pub body: Option<Value>,
2853}
2854
2855impl PostTextAesDecryptAdvancedParams {
2856 pub fn new() -> Self {
2857 Self {
2858 body: None,
2859 }
2860 }
2861 pub fn body(mut self, value: Value) -> Self {
2862 self.body = Some(value);
2863 self
2864 }
2865}
2866
2867#[derive(Debug, Clone)]
2868pub struct PostTextAesEncryptParams {
2869 pub body: Option<Value>,
2870}
2871
2872impl PostTextAesEncryptParams {
2873 pub fn new() -> Self {
2874 Self {
2875 body: None,
2876 }
2877 }
2878 pub fn body(mut self, value: Value) -> Self {
2879 self.body = Some(value);
2880 self
2881 }
2882}
2883
2884#[derive(Debug, Clone)]
2885pub struct PostTextAesEncryptAdvancedParams {
2886 pub body: Option<Value>,
2887}
2888
2889impl PostTextAesEncryptAdvancedParams {
2890 pub fn new() -> Self {
2891 Self {
2892 body: None,
2893 }
2894 }
2895 pub fn body(mut self, value: Value) -> Self {
2896 self.body = Some(value);
2897 self
2898 }
2899}
2900
2901#[derive(Debug, Clone)]
2902pub struct PostTextAnalyzeParams {
2903 pub body: Option<Value>,
2904}
2905
2906impl PostTextAnalyzeParams {
2907 pub fn new() -> Self {
2908 Self {
2909 body: None,
2910 }
2911 }
2912 pub fn body(mut self, value: Value) -> Self {
2913 self.body = Some(value);
2914 self
2915 }
2916}
2917
2918#[derive(Debug, Clone)]
2919pub struct PostTextBase64DecodeParams {
2920 pub body: Option<Value>,
2921}
2922
2923impl PostTextBase64DecodeParams {
2924 pub fn new() -> Self {
2925 Self {
2926 body: None,
2927 }
2928 }
2929 pub fn body(mut self, value: Value) -> Self {
2930 self.body = Some(value);
2931 self
2932 }
2933}
2934
2935#[derive(Debug, Clone)]
2936pub struct PostTextBase64EncodeParams {
2937 pub body: Option<Value>,
2938}
2939
2940impl PostTextBase64EncodeParams {
2941 pub fn new() -> Self {
2942 Self {
2943 body: None,
2944 }
2945 }
2946 pub fn body(mut self, value: Value) -> Self {
2947 self.body = Some(value);
2948 self
2949 }
2950}
2951
2952#[derive(Debug, Clone)]
2953pub struct PostTextConvertParams {
2954 pub body: Option<Value>,
2955}
2956
2957impl PostTextConvertParams {
2958 pub fn new() -> Self {
2959 Self {
2960 body: None,
2961 }
2962 }
2963 pub fn body(mut self, value: Value) -> Self {
2964 self.body = Some(value);
2965 self
2966 }
2967}
2968
2969#[derive(Debug, Clone)]
2970pub struct PostTextMd5Params {
2971 pub body: Option<Value>,
2972}
2973
2974impl PostTextMd5Params {
2975 pub fn new() -> Self {
2976 Self {
2977 body: None,
2978 }
2979 }
2980 pub fn body(mut self, value: Value) -> Self {
2981 self.body = Some(value);
2982 self
2983 }
2984}
2985
2986#[derive(Debug, Clone)]
2987pub struct PostTextMd5VerifyParams {
2988 pub body: Option<Value>,
2989}
2990
2991impl PostTextMd5VerifyParams {
2992 pub fn new() -> Self {
2993 Self {
2994 body: None,
2995 }
2996 }
2997 pub fn body(mut self, value: Value) -> Self {
2998 self.body = Some(value);
2999 self
3000 }
3001}
3002#[derive(Debug, Clone)]
3003pub struct TranslateService<'a> {
3004 pub(crate) client: &'a Client,
3005}
3006
3007impl<'a> TranslateService<'a> {
3008#[instrument(skip(self))]
3010 pub async fn get_ai_translate_languages(&self) -> Result<Value> {
3011 let mut path = "/api/v1/ai/translate/languages".to_string();
3012
3013 let mut query: Vec<(String, String)> = Vec::new();
3014 let query = if query.is_empty() { None } else { Some(query) };
3015
3016 let mut extra_headers = HeaderMap::new();
3017 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3018 let body = None;
3019
3020 self.client
3021 .request_json(
3022 Method::GET,
3023 &path,
3024 headers,
3025 query,
3026 body,
3027 )
3028 .await
3029 }
3030#[instrument(skip(self, params))]
3032 pub async fn post_ai_translate(&self, params: PostAiTranslateParams) -> Result<Value> {
3033 let mut path = "/api/v1/ai/translate".to_string();
3034
3035 let mut query: Vec<(String, String)> = Vec::new();
3036 query.push(("target_lang".to_string(), params.target_lang_query.clone()));
3037 let query = if query.is_empty() { None } else { Some(query) };
3038
3039 let mut extra_headers = HeaderMap::new();
3040 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3041 let body = params.body.clone();
3042
3043 self.client
3044 .request_json(
3045 Method::POST,
3046 &path,
3047 headers,
3048 query,
3049 body,
3050 )
3051 .await
3052 }
3053#[instrument(skip(self, params))]
3055 pub async fn post_translate_stream(&self, params: PostTranslateStreamParams) -> Result<Value> {
3056 let mut path = "/api/v1/translate/stream".to_string();
3057
3058 let mut query: Vec<(String, String)> = Vec::new();
3059 let query = if query.is_empty() { None } else { Some(query) };
3060
3061 let mut extra_headers = HeaderMap::new();
3062 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3063 let body = params.body.clone();
3064
3065 self.client
3066 .request_json(
3067 Method::POST,
3068 &path,
3069 headers,
3070 query,
3071 body,
3072 )
3073 .await
3074 }
3075#[instrument(skip(self, params))]
3077 pub async fn post_translate_text(&self, params: PostTranslateTextParams) -> Result<Value> {
3078 let mut path = "/api/v1/translate/text".to_string();
3079
3080 let mut query: Vec<(String, String)> = Vec::new();
3081 query.push(("to_lang".to_string(), params.to_lang_query.clone()));
3082 let query = if query.is_empty() { None } else { Some(query) };
3083
3084 let mut extra_headers = HeaderMap::new();
3085 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3086 let body = params.body.clone();
3087
3088 self.client
3089 .request_json(
3090 Method::POST,
3091 &path,
3092 headers,
3093 query,
3094 body,
3095 )
3096 .await
3097 }
3098}
3099
3100
3101#[derive(Debug, Clone)]
3102pub struct PostAiTranslateParams {
3103 pub target_lang_query: String,
3104 pub body: Option<Value>,
3105}
3106
3107impl PostAiTranslateParams {
3108 pub fn new(target_lang_query: impl Into<String>) -> Self {
3109 Self {
3110 target_lang_query: target_lang_query.into(),
3111 body: None,
3112 }
3113 }
3114 pub fn body(mut self, value: Value) -> Self {
3115 self.body = Some(value);
3116 self
3117 }
3118}
3119
3120#[derive(Debug, Clone)]
3121pub struct PostTranslateStreamParams {
3122 pub body: Option<Value>,
3123}
3124
3125impl PostTranslateStreamParams {
3126 pub fn new() -> Self {
3127 Self {
3128 body: None,
3129 }
3130 }
3131 pub fn body(mut self, value: Value) -> Self {
3132 self.body = Some(value);
3133 self
3134 }
3135}
3136
3137#[derive(Debug, Clone)]
3138pub struct PostTranslateTextParams {
3139 pub to_lang_query: String,
3140 pub body: Option<Value>,
3141}
3142
3143impl PostTranslateTextParams {
3144 pub fn new(to_lang_query: impl Into<String>) -> Self {
3145 Self {
3146 to_lang_query: to_lang_query.into(),
3147 body: None,
3148 }
3149 }
3150 pub fn body(mut self, value: Value) -> Self {
3151 self.body = Some(value);
3152 self
3153 }
3154}
3155#[derive(Debug, Clone)]
3156pub struct WebparseService<'a> {
3157 pub(crate) client: &'a Client,
3158}
3159
3160impl<'a> WebparseService<'a> {
3161#[instrument(skip(self, params))]
3163 pub async fn get_web_tomarkdown_async_status(&self, params: GetWebTomarkdownAsyncStatusParams) -> Result<Value> {
3164 let mut path = "/api/v1/web/tomarkdown/async/{task_id}".to_string();
3165 {
3166 let encoded = encode(¶ms.task_id_path).into_owned();
3167 path = path.replace("{task_id}", &encoded);
3168 }
3169
3170 let mut query: Vec<(String, String)> = Vec::new();
3171 let query = if query.is_empty() { None } else { Some(query) };
3172
3173 let mut extra_headers = HeaderMap::new();
3174 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3175 let body = None;
3176
3177 self.client
3178 .request_json(
3179 Method::GET,
3180 &path,
3181 headers,
3182 query,
3183 body,
3184 )
3185 .await
3186 }
3187#[instrument(skip(self, params))]
3189 pub async fn get_webparse_extractimages(&self, params: GetWebparseExtractimagesParams) -> Result<Value> {
3190 let mut path = "/api/v1/webparse/extractimages".to_string();
3191
3192 let mut query: Vec<(String, String)> = Vec::new();
3193 query.push(("url".to_string(), params.url_query.clone()));
3194 let query = if query.is_empty() { None } else { Some(query) };
3195
3196 let mut extra_headers = HeaderMap::new();
3197 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3198 let body = None;
3199
3200 self.client
3201 .request_json(
3202 Method::GET,
3203 &path,
3204 headers,
3205 query,
3206 body,
3207 )
3208 .await
3209 }
3210#[instrument(skip(self, params))]
3212 pub async fn get_webparse_metadata(&self, params: GetWebparseMetadataParams) -> Result<Value> {
3213 let mut path = "/api/v1/webparse/metadata".to_string();
3214
3215 let mut query: Vec<(String, String)> = Vec::new();
3216 query.push(("url".to_string(), params.url_query.clone()));
3217 let query = if query.is_empty() { None } else { Some(query) };
3218
3219 let mut extra_headers = HeaderMap::new();
3220 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3221 let body = None;
3222
3223 self.client
3224 .request_json(
3225 Method::GET,
3226 &path,
3227 headers,
3228 query,
3229 body,
3230 )
3231 .await
3232 }
3233#[instrument(skip(self, params))]
3235 pub async fn post_web_tomarkdown_async(&self, params: PostWebTomarkdownAsyncParams) -> Result<Value> {
3236 let mut path = "/api/v1/web/tomarkdown/async".to_string();
3237
3238 let mut query: Vec<(String, String)> = Vec::new();
3239 query.push(("url".to_string(), params.url_query.clone()));
3240 let query = if query.is_empty() { None } else { Some(query) };
3241
3242 let mut extra_headers = HeaderMap::new();
3243 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3244 let body = None;
3245
3246 self.client
3247 .request_json(
3248 Method::POST,
3249 &path,
3250 headers,
3251 query,
3252 body,
3253 )
3254 .await
3255 }
3256}
3257
3258#[derive(Debug, Clone)]
3259pub struct GetWebTomarkdownAsyncStatusParams {
3260 pub task_id_path: String,
3261}
3262
3263impl GetWebTomarkdownAsyncStatusParams {
3264 pub fn new(task_id_path: impl Into<String>) -> Self {
3265 Self {
3266 task_id_path: task_id_path.into(),
3267 }
3268 }
3269}
3270
3271#[derive(Debug, Clone)]
3272pub struct GetWebparseExtractimagesParams {
3273 pub url_query: String,
3274}
3275
3276impl GetWebparseExtractimagesParams {
3277 pub fn new(url_query: impl Into<String>) -> Self {
3278 Self {
3279 url_query: url_query.into(),
3280 }
3281 }
3282}
3283
3284#[derive(Debug, Clone)]
3285pub struct GetWebparseMetadataParams {
3286 pub url_query: String,
3287}
3288
3289impl GetWebparseMetadataParams {
3290 pub fn new(url_query: impl Into<String>) -> Self {
3291 Self {
3292 url_query: url_query.into(),
3293 }
3294 }
3295}
3296
3297#[derive(Debug, Clone)]
3298pub struct PostWebTomarkdownAsyncParams {
3299 pub url_query: String,
3300}
3301
3302impl PostWebTomarkdownAsyncParams {
3303 pub fn new(url_query: impl Into<String>) -> Self {
3304 Self {
3305 url_query: url_query.into(),
3306 }
3307 }
3308}
3309#[derive(Debug, Clone)]
3310pub struct MinGanCiShiBieService<'a> {
3311 pub(crate) client: &'a Client,
3312}
3313
3314impl<'a> MinGanCiShiBieService<'a> {
3315#[instrument(skip(self, params))]
3317 pub async fn get_sensitive_word_analyze_query(&self, params: GetSensitiveWordAnalyzeQueryParams) -> Result<Value> {
3318 let mut path = "/api/v1/sensitive-word/analyze-query".to_string();
3319
3320 let mut query: Vec<(String, String)> = Vec::new();
3321 query.push(("keyword".to_string(), params.keyword_query.clone()));
3322 let query = if query.is_empty() { None } else { Some(query) };
3323
3324 let mut extra_headers = HeaderMap::new();
3325 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3326 let body = None;
3327
3328 self.client
3329 .request_json(
3330 Method::GET,
3331 &path,
3332 headers,
3333 query,
3334 body,
3335 )
3336 .await
3337 }
3338#[instrument(skip(self, params))]
3340 pub async fn post_sensitive_word_analyze(&self, params: PostSensitiveWordAnalyzeParams) -> Result<Value> {
3341 let mut path = "/api/v1/sensitive-word/analyze".to_string();
3342
3343 let mut query: Vec<(String, String)> = Vec::new();
3344 let query = if query.is_empty() { None } else { Some(query) };
3345
3346 let mut extra_headers = HeaderMap::new();
3347 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3348 let body = params.body.clone();
3349
3350 self.client
3351 .request_json(
3352 Method::POST,
3353 &path,
3354 headers,
3355 query,
3356 body,
3357 )
3358 .await
3359 }
3360#[instrument(skip(self, params))]
3362 pub async fn post_sensitive_word_quick_check(&self, params: PostSensitiveWordQuickCheckParams) -> Result<Value> {
3363 let mut path = "/api/v1/text/profanitycheck".to_string();
3364
3365 let mut query: Vec<(String, String)> = Vec::new();
3366 let query = if query.is_empty() { None } else { Some(query) };
3367
3368 let mut extra_headers = HeaderMap::new();
3369 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3370 let body = params.body.clone();
3371
3372 self.client
3373 .request_json(
3374 Method::POST,
3375 &path,
3376 headers,
3377 query,
3378 body,
3379 )
3380 .await
3381 }
3382}
3383
3384#[derive(Debug, Clone)]
3385pub struct GetSensitiveWordAnalyzeQueryParams {
3386 pub keyword_query: String,
3387}
3388
3389impl GetSensitiveWordAnalyzeQueryParams {
3390 pub fn new(keyword_query: impl Into<String>) -> Self {
3391 Self {
3392 keyword_query: keyword_query.into(),
3393 }
3394 }
3395}
3396
3397#[derive(Debug, Clone)]
3398pub struct PostSensitiveWordAnalyzeParams {
3399 pub body: Option<Value>,
3400}
3401
3402impl PostSensitiveWordAnalyzeParams {
3403 pub fn new() -> Self {
3404 Self {
3405 body: None,
3406 }
3407 }
3408 pub fn body(mut self, value: Value) -> Self {
3409 self.body = Some(value);
3410 self
3411 }
3412}
3413
3414#[derive(Debug, Clone)]
3415pub struct PostSensitiveWordQuickCheckParams {
3416 pub body: Option<Value>,
3417}
3418
3419impl PostSensitiveWordQuickCheckParams {
3420 pub fn new() -> Self {
3421 Self {
3422 body: None,
3423 }
3424 }
3425 pub fn body(mut self, value: Value) -> Self {
3426 self.body = Some(value);
3427 self
3428 }
3429}
3430#[derive(Debug, Clone)]
3431pub struct ZhiNengSouSuoService<'a> {
3432 pub(crate) client: &'a Client,
3433}
3434
3435impl<'a> ZhiNengSouSuoService<'a> {
3436#[instrument(skip(self))]
3438 pub async fn get_search_engines(&self) -> Result<Value> {
3439 let mut path = "/api/v1/search/engines".to_string();
3440
3441 let mut query: Vec<(String, String)> = Vec::new();
3442 let query = if query.is_empty() { None } else { Some(query) };
3443
3444 let mut extra_headers = HeaderMap::new();
3445 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3446 let body = None;
3447
3448 self.client
3449 .request_json(
3450 Method::GET,
3451 &path,
3452 headers,
3453 query,
3454 body,
3455 )
3456 .await
3457 }
3458#[instrument(skip(self, params))]
3460 pub async fn post_search_aggregate(&self, params: PostSearchAggregateParams) -> Result<Value> {
3461 let mut path = "/api/v1/search/aggregate".to_string();
3462
3463 let mut query: Vec<(String, String)> = Vec::new();
3464 let query = if query.is_empty() { None } else { Some(query) };
3465
3466 let mut extra_headers = HeaderMap::new();
3467 let headers = if extra_headers.is_empty() { None } else { Some(extra_headers) };
3468 let body = params.body.clone();
3469
3470 self.client
3471 .request_json(
3472 Method::POST,
3473 &path,
3474 headers,
3475 query,
3476 body,
3477 )
3478 .await
3479 }
3480}
3481
3482
3483#[derive(Debug, Clone)]
3484pub struct PostSearchAggregateParams {
3485 pub body: Option<Value>,
3486}
3487
3488impl PostSearchAggregateParams {
3489 pub fn new() -> Self {
3490 Self {
3491 body: None,
3492 }
3493 }
3494 pub fn body(mut self, value: Value) -> Self {
3495 self.body = Some(value);
3496 self
3497 }
3498}