1pub struct AtpServiceClient<T>
5where
6 T: atrium_xrpc::XrpcClient + Send + Sync,
7{
8 pub service: Service<T>,
9}
10impl<T> AtpServiceClient<T>
11where
12 T: atrium_xrpc::XrpcClient + Send + Sync,
13{
14 pub fn new(xrpc: T) -> Self {
15 Self {
16 service: Service::new(std::sync::Arc::new(xrpc)),
17 }
18 }
19}
20pub struct Service<T>
21where
22 T: atrium_xrpc::XrpcClient + Send + Sync,
23{
24 pub app: app::Service<T>,
25 pub chat: chat::Service<T>,
26 pub com: com::Service<T>,
27 pub tools: tools::Service<T>,
28 pub(crate) _phantom: core::marker::PhantomData<T>,
29}
30pub mod app {
31 pub struct Service<T>
32 where
33 T: atrium_xrpc::XrpcClient + Send + Sync,
34 {
35 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-appbsky")))]
36 #[cfg(feature = "namespace-appbsky")]
37 pub bsky: bsky::Service<T>,
38 pub(crate) _phantom: core::marker::PhantomData<T>,
39 }
40 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-appbsky")))]
41 #[cfg(feature = "namespace-appbsky")]
42 pub mod bsky {
43 pub struct Service<T>
44 where
45 T: atrium_xrpc::XrpcClient + Send + Sync,
46 {
47 pub actor: actor::Service<T>,
48 pub feed: feed::Service<T>,
49 pub graph: graph::Service<T>,
50 pub labeler: labeler::Service<T>,
51 pub notification: notification::Service<T>,
52 pub unspecced: unspecced::Service<T>,
53 pub video: video::Service<T>,
54 pub(crate) _phantom: core::marker::PhantomData<T>,
55 }
56 pub mod actor {
57 pub struct Service<T>
58 where
59 T: atrium_xrpc::XrpcClient + Send + Sync,
60 {
61 pub(crate) xrpc: std::sync::Arc<T>,
62 pub(crate) _phantom: core::marker::PhantomData<T>,
63 }
64 }
65 pub mod feed {
66 pub struct Service<T>
67 where
68 T: atrium_xrpc::XrpcClient + Send + Sync,
69 {
70 pub(crate) xrpc: std::sync::Arc<T>,
71 pub(crate) _phantom: core::marker::PhantomData<T>,
72 }
73 }
74 pub mod graph {
75 pub struct Service<T>
76 where
77 T: atrium_xrpc::XrpcClient + Send + Sync,
78 {
79 pub(crate) xrpc: std::sync::Arc<T>,
80 pub(crate) _phantom: core::marker::PhantomData<T>,
81 }
82 }
83 pub mod labeler {
84 pub struct Service<T>
85 where
86 T: atrium_xrpc::XrpcClient + Send + Sync,
87 {
88 pub(crate) xrpc: std::sync::Arc<T>,
89 pub(crate) _phantom: core::marker::PhantomData<T>,
90 }
91 }
92 pub mod notification {
93 pub struct Service<T>
94 where
95 T: atrium_xrpc::XrpcClient + Send + Sync,
96 {
97 pub(crate) xrpc: std::sync::Arc<T>,
98 pub(crate) _phantom: core::marker::PhantomData<T>,
99 }
100 }
101 pub mod unspecced {
102 pub struct Service<T>
103 where
104 T: atrium_xrpc::XrpcClient + Send + Sync,
105 {
106 pub(crate) xrpc: std::sync::Arc<T>,
107 pub(crate) _phantom: core::marker::PhantomData<T>,
108 }
109 }
110 pub mod video {
111 pub struct Service<T>
112 where
113 T: atrium_xrpc::XrpcClient + Send + Sync,
114 {
115 pub(crate) xrpc: std::sync::Arc<T>,
116 pub(crate) _phantom: core::marker::PhantomData<T>,
117 }
118 }
119 }
120}
121pub mod chat {
122 pub struct Service<T>
123 where
124 T: atrium_xrpc::XrpcClient + Send + Sync,
125 {
126 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-chatbsky")))]
127 #[cfg(feature = "namespace-chatbsky")]
128 pub bsky: bsky::Service<T>,
129 pub(crate) _phantom: core::marker::PhantomData<T>,
130 }
131 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-chatbsky")))]
132 #[cfg(feature = "namespace-chatbsky")]
133 pub mod bsky {
134 pub struct Service<T>
135 where
136 T: atrium_xrpc::XrpcClient + Send + Sync,
137 {
138 pub actor: actor::Service<T>,
139 pub convo: convo::Service<T>,
140 pub moderation: moderation::Service<T>,
141 pub(crate) _phantom: core::marker::PhantomData<T>,
142 }
143 pub mod actor {
144 pub struct Service<T>
145 where
146 T: atrium_xrpc::XrpcClient + Send + Sync,
147 {
148 pub(crate) xrpc: std::sync::Arc<T>,
149 pub(crate) _phantom: core::marker::PhantomData<T>,
150 }
151 }
152 pub mod convo {
153 pub struct Service<T>
154 where
155 T: atrium_xrpc::XrpcClient + Send + Sync,
156 {
157 pub(crate) xrpc: std::sync::Arc<T>,
158 pub(crate) _phantom: core::marker::PhantomData<T>,
159 }
160 }
161 pub mod moderation {
162 pub struct Service<T>
163 where
164 T: atrium_xrpc::XrpcClient + Send + Sync,
165 {
166 pub(crate) xrpc: std::sync::Arc<T>,
167 pub(crate) _phantom: core::marker::PhantomData<T>,
168 }
169 }
170 }
171}
172pub mod com {
173 pub struct Service<T>
174 where
175 T: atrium_xrpc::XrpcClient + Send + Sync,
176 {
177 pub atproto: atproto::Service<T>,
178 pub(crate) _phantom: core::marker::PhantomData<T>,
179 }
180 pub mod atproto {
181 pub struct Service<T>
182 where
183 T: atrium_xrpc::XrpcClient + Send + Sync,
184 {
185 pub admin: admin::Service<T>,
186 pub identity: identity::Service<T>,
187 pub label: label::Service<T>,
188 pub moderation: moderation::Service<T>,
189 pub repo: repo::Service<T>,
190 pub server: server::Service<T>,
191 pub sync: sync::Service<T>,
192 pub temp: temp::Service<T>,
193 pub(crate) _phantom: core::marker::PhantomData<T>,
194 }
195 pub mod admin {
196 pub struct Service<T>
197 where
198 T: atrium_xrpc::XrpcClient + Send + Sync,
199 {
200 pub(crate) xrpc: std::sync::Arc<T>,
201 pub(crate) _phantom: core::marker::PhantomData<T>,
202 }
203 }
204 pub mod identity {
205 pub struct Service<T>
206 where
207 T: atrium_xrpc::XrpcClient + Send + Sync,
208 {
209 pub(crate) xrpc: std::sync::Arc<T>,
210 pub(crate) _phantom: core::marker::PhantomData<T>,
211 }
212 }
213 pub mod label {
214 pub struct Service<T>
215 where
216 T: atrium_xrpc::XrpcClient + Send + Sync,
217 {
218 pub(crate) xrpc: std::sync::Arc<T>,
219 pub(crate) _phantom: core::marker::PhantomData<T>,
220 }
221 }
222 pub mod moderation {
223 pub struct Service<T>
224 where
225 T: atrium_xrpc::XrpcClient + Send + Sync,
226 {
227 pub(crate) xrpc: std::sync::Arc<T>,
228 pub(crate) _phantom: core::marker::PhantomData<T>,
229 }
230 }
231 pub mod repo {
232 pub struct Service<T>
233 where
234 T: atrium_xrpc::XrpcClient + Send + Sync,
235 {
236 pub(crate) xrpc: std::sync::Arc<T>,
237 pub(crate) _phantom: core::marker::PhantomData<T>,
238 }
239 }
240 pub mod server {
241 pub struct Service<T>
242 where
243 T: atrium_xrpc::XrpcClient + Send + Sync,
244 {
245 pub(crate) xrpc: std::sync::Arc<T>,
246 pub(crate) _phantom: core::marker::PhantomData<T>,
247 }
248 }
249 pub mod sync {
250 pub struct Service<T>
251 where
252 T: atrium_xrpc::XrpcClient + Send + Sync,
253 {
254 pub(crate) xrpc: std::sync::Arc<T>,
255 pub(crate) _phantom: core::marker::PhantomData<T>,
256 }
257 }
258 pub mod temp {
259 pub struct Service<T>
260 where
261 T: atrium_xrpc::XrpcClient + Send + Sync,
262 {
263 pub(crate) xrpc: std::sync::Arc<T>,
264 pub(crate) _phantom: core::marker::PhantomData<T>,
265 }
266 }
267 }
268}
269pub mod tools {
270 pub struct Service<T>
271 where
272 T: atrium_xrpc::XrpcClient + Send + Sync,
273 {
274 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-toolsozone")))]
275 #[cfg(feature = "namespace-toolsozone")]
276 pub ozone: ozone::Service<T>,
277 pub(crate) _phantom: core::marker::PhantomData<T>,
278 }
279 #[cfg_attr(docsrs, doc(cfg(feature = "namespace-toolsozone")))]
280 #[cfg(feature = "namespace-toolsozone")]
281 pub mod ozone {
282 pub struct Service<T>
283 where
284 T: atrium_xrpc::XrpcClient + Send + Sync,
285 {
286 pub communication: communication::Service<T>,
287 pub moderation: moderation::Service<T>,
288 pub server: server::Service<T>,
289 pub set: set::Service<T>,
290 pub setting: setting::Service<T>,
291 pub signature: signature::Service<T>,
292 pub team: team::Service<T>,
293 pub(crate) _phantom: core::marker::PhantomData<T>,
294 }
295 pub mod communication {
296 pub struct Service<T>
297 where
298 T: atrium_xrpc::XrpcClient + Send + Sync,
299 {
300 pub(crate) xrpc: std::sync::Arc<T>,
301 pub(crate) _phantom: core::marker::PhantomData<T>,
302 }
303 }
304 pub mod moderation {
305 pub struct Service<T>
306 where
307 T: atrium_xrpc::XrpcClient + Send + Sync,
308 {
309 pub(crate) xrpc: std::sync::Arc<T>,
310 pub(crate) _phantom: core::marker::PhantomData<T>,
311 }
312 }
313 pub mod server {
314 pub struct Service<T>
315 where
316 T: atrium_xrpc::XrpcClient + Send + Sync,
317 {
318 pub(crate) xrpc: std::sync::Arc<T>,
319 pub(crate) _phantom: core::marker::PhantomData<T>,
320 }
321 }
322 pub mod set {
323 pub struct Service<T>
324 where
325 T: atrium_xrpc::XrpcClient + Send + Sync,
326 {
327 pub(crate) xrpc: std::sync::Arc<T>,
328 pub(crate) _phantom: core::marker::PhantomData<T>,
329 }
330 }
331 pub mod setting {
332 pub struct Service<T>
333 where
334 T: atrium_xrpc::XrpcClient + Send + Sync,
335 {
336 pub(crate) xrpc: std::sync::Arc<T>,
337 pub(crate) _phantom: core::marker::PhantomData<T>,
338 }
339 }
340 pub mod signature {
341 pub struct Service<T>
342 where
343 T: atrium_xrpc::XrpcClient + Send + Sync,
344 {
345 pub(crate) xrpc: std::sync::Arc<T>,
346 pub(crate) _phantom: core::marker::PhantomData<T>,
347 }
348 }
349 pub mod team {
350 pub struct Service<T>
351 where
352 T: atrium_xrpc::XrpcClient + Send + Sync,
353 {
354 pub(crate) xrpc: std::sync::Arc<T>,
355 pub(crate) _phantom: core::marker::PhantomData<T>,
356 }
357 }
358 }
359}
360impl<T> self::Service<T>
361where
362 T: atrium_xrpc::XrpcClient + Send + Sync,
363{
364 #[allow(unused_variables)]
365 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
366 Self {
367 app: app::Service::new(std::sync::Arc::clone(&xrpc)),
368 chat: chat::Service::new(std::sync::Arc::clone(&xrpc)),
369 com: com::Service::new(std::sync::Arc::clone(&xrpc)),
370 tools: tools::Service::new(std::sync::Arc::clone(&xrpc)),
371 _phantom: core::marker::PhantomData,
372 }
373 }
374}
375impl<T> app::Service<T>
376where
377 T: atrium_xrpc::XrpcClient + Send + Sync,
378{
379 #[allow(unused_variables)]
380 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
381 Self {
382 #[cfg(feature = "namespace-appbsky")]
383 bsky: app::bsky::Service::new(std::sync::Arc::clone(&xrpc)),
384 _phantom: core::marker::PhantomData,
385 }
386 }
387}
388#[cfg(feature = "namespace-appbsky")]
389impl<T> app::bsky::Service<T>
390where
391 T: atrium_xrpc::XrpcClient + Send + Sync,
392{
393 #[allow(unused_variables)]
394 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
395 Self {
396 actor: app::bsky::actor::Service::new(std::sync::Arc::clone(&xrpc)),
397 feed: app::bsky::feed::Service::new(std::sync::Arc::clone(&xrpc)),
398 graph: app::bsky::graph::Service::new(std::sync::Arc::clone(&xrpc)),
399 labeler: app::bsky::labeler::Service::new(std::sync::Arc::clone(&xrpc)),
400 notification: app::bsky::notification::Service::new(
401 std::sync::Arc::clone(&xrpc),
402 ),
403 unspecced: app::bsky::unspecced::Service::new(std::sync::Arc::clone(&xrpc)),
404 video: app::bsky::video::Service::new(std::sync::Arc::clone(&xrpc)),
405 _phantom: core::marker::PhantomData,
406 }
407 }
408}
409#[cfg(feature = "namespace-appbsky")]
410impl<T> app::bsky::actor::Service<T>
411where
412 T: atrium_xrpc::XrpcClient + Send + Sync,
413{
414 #[allow(unused_variables)]
415 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
416 Self {
417 xrpc,
418 _phantom: core::marker::PhantomData,
419 }
420 }
421 pub async fn get_preferences(
423 &self,
424 params: crate::app::bsky::actor::get_preferences::Parameters,
425 ) -> atrium_xrpc::Result<
426 crate::app::bsky::actor::get_preferences::Output,
427 crate::app::bsky::actor::get_preferences::Error,
428 > {
429 let response = self
430 .xrpc
431 .send_xrpc::<
432 _,
433 (),
434 _,
435 _,
436 >(
437 &atrium_xrpc::XrpcRequest {
438 method: http::Method::GET,
439 nsid: crate::app::bsky::actor::get_preferences::NSID.into(),
440 parameters: Some(params),
441 input: None,
442 encoding: None,
443 },
444 )
445 .await?;
446 match response {
447 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
448 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
449 }
450 }
451 pub async fn get_profile(
453 &self,
454 params: crate::app::bsky::actor::get_profile::Parameters,
455 ) -> atrium_xrpc::Result<
456 crate::app::bsky::actor::get_profile::Output,
457 crate::app::bsky::actor::get_profile::Error,
458 > {
459 let response = self
460 .xrpc
461 .send_xrpc::<
462 _,
463 (),
464 _,
465 _,
466 >(
467 &atrium_xrpc::XrpcRequest {
468 method: http::Method::GET,
469 nsid: crate::app::bsky::actor::get_profile::NSID.into(),
470 parameters: Some(params),
471 input: None,
472 encoding: None,
473 },
474 )
475 .await?;
476 match response {
477 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
478 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
479 }
480 }
481 pub async fn get_profiles(
483 &self,
484 params: crate::app::bsky::actor::get_profiles::Parameters,
485 ) -> atrium_xrpc::Result<
486 crate::app::bsky::actor::get_profiles::Output,
487 crate::app::bsky::actor::get_profiles::Error,
488 > {
489 let response = self
490 .xrpc
491 .send_xrpc::<
492 _,
493 (),
494 _,
495 _,
496 >(
497 &atrium_xrpc::XrpcRequest {
498 method: http::Method::GET,
499 nsid: crate::app::bsky::actor::get_profiles::NSID.into(),
500 parameters: Some(params),
501 input: None,
502 encoding: None,
503 },
504 )
505 .await?;
506 match response {
507 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
508 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
509 }
510 }
511 pub async fn get_suggestions(
513 &self,
514 params: crate::app::bsky::actor::get_suggestions::Parameters,
515 ) -> atrium_xrpc::Result<
516 crate::app::bsky::actor::get_suggestions::Output,
517 crate::app::bsky::actor::get_suggestions::Error,
518 > {
519 let response = self
520 .xrpc
521 .send_xrpc::<
522 _,
523 (),
524 _,
525 _,
526 >(
527 &atrium_xrpc::XrpcRequest {
528 method: http::Method::GET,
529 nsid: crate::app::bsky::actor::get_suggestions::NSID.into(),
530 parameters: Some(params),
531 input: None,
532 encoding: None,
533 },
534 )
535 .await?;
536 match response {
537 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
538 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
539 }
540 }
541 pub async fn put_preferences(
543 &self,
544 input: crate::app::bsky::actor::put_preferences::Input,
545 ) -> atrium_xrpc::Result<(), crate::app::bsky::actor::put_preferences::Error> {
546 let response = self
547 .xrpc
548 .send_xrpc::<
549 (),
550 _,
551 (),
552 _,
553 >(
554 &atrium_xrpc::XrpcRequest {
555 method: http::Method::POST,
556 nsid: crate::app::bsky::actor::put_preferences::NSID.into(),
557 parameters: None,
558 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
559 encoding: Some(String::from("application/json")),
560 },
561 )
562 .await?;
563 match response {
564 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
565 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
566 }
567 }
568 pub async fn search_actors(
570 &self,
571 params: crate::app::bsky::actor::search_actors::Parameters,
572 ) -> atrium_xrpc::Result<
573 crate::app::bsky::actor::search_actors::Output,
574 crate::app::bsky::actor::search_actors::Error,
575 > {
576 let response = self
577 .xrpc
578 .send_xrpc::<
579 _,
580 (),
581 _,
582 _,
583 >(
584 &atrium_xrpc::XrpcRequest {
585 method: http::Method::GET,
586 nsid: crate::app::bsky::actor::search_actors::NSID.into(),
587 parameters: Some(params),
588 input: None,
589 encoding: None,
590 },
591 )
592 .await?;
593 match response {
594 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
595 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
596 }
597 }
598 pub async fn search_actors_typeahead(
600 &self,
601 params: crate::app::bsky::actor::search_actors_typeahead::Parameters,
602 ) -> atrium_xrpc::Result<
603 crate::app::bsky::actor::search_actors_typeahead::Output,
604 crate::app::bsky::actor::search_actors_typeahead::Error,
605 > {
606 let response = self
607 .xrpc
608 .send_xrpc::<
609 _,
610 (),
611 _,
612 _,
613 >(
614 &atrium_xrpc::XrpcRequest {
615 method: http::Method::GET,
616 nsid: crate::app::bsky::actor::search_actors_typeahead::NSID.into(),
617 parameters: Some(params),
618 input: None,
619 encoding: None,
620 },
621 )
622 .await?;
623 match response {
624 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
625 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
626 }
627 }
628}
629#[cfg(feature = "namespace-appbsky")]
630impl<T> app::bsky::feed::Service<T>
631where
632 T: atrium_xrpc::XrpcClient + Send + Sync,
633{
634 #[allow(unused_variables)]
635 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
636 Self {
637 xrpc,
638 _phantom: core::marker::PhantomData,
639 }
640 }
641 pub async fn describe_feed_generator(
643 &self,
644 ) -> atrium_xrpc::Result<
645 crate::app::bsky::feed::describe_feed_generator::Output,
646 crate::app::bsky::feed::describe_feed_generator::Error,
647 > {
648 let response = self
649 .xrpc
650 .send_xrpc::<
651 (),
652 (),
653 _,
654 _,
655 >(
656 &atrium_xrpc::XrpcRequest {
657 method: http::Method::GET,
658 nsid: crate::app::bsky::feed::describe_feed_generator::NSID.into(),
659 parameters: None,
660 input: None,
661 encoding: None,
662 },
663 )
664 .await?;
665 match response {
666 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
667 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
668 }
669 }
670 pub async fn get_actor_feeds(
672 &self,
673 params: crate::app::bsky::feed::get_actor_feeds::Parameters,
674 ) -> atrium_xrpc::Result<
675 crate::app::bsky::feed::get_actor_feeds::Output,
676 crate::app::bsky::feed::get_actor_feeds::Error,
677 > {
678 let response = self
679 .xrpc
680 .send_xrpc::<
681 _,
682 (),
683 _,
684 _,
685 >(
686 &atrium_xrpc::XrpcRequest {
687 method: http::Method::GET,
688 nsid: crate::app::bsky::feed::get_actor_feeds::NSID.into(),
689 parameters: Some(params),
690 input: None,
691 encoding: None,
692 },
693 )
694 .await?;
695 match response {
696 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
697 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
698 }
699 }
700 pub async fn get_actor_likes(
702 &self,
703 params: crate::app::bsky::feed::get_actor_likes::Parameters,
704 ) -> atrium_xrpc::Result<
705 crate::app::bsky::feed::get_actor_likes::Output,
706 crate::app::bsky::feed::get_actor_likes::Error,
707 > {
708 let response = self
709 .xrpc
710 .send_xrpc::<
711 _,
712 (),
713 _,
714 _,
715 >(
716 &atrium_xrpc::XrpcRequest {
717 method: http::Method::GET,
718 nsid: crate::app::bsky::feed::get_actor_likes::NSID.into(),
719 parameters: Some(params),
720 input: None,
721 encoding: None,
722 },
723 )
724 .await?;
725 match response {
726 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
727 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
728 }
729 }
730 pub async fn get_author_feed(
732 &self,
733 params: crate::app::bsky::feed::get_author_feed::Parameters,
734 ) -> atrium_xrpc::Result<
735 crate::app::bsky::feed::get_author_feed::Output,
736 crate::app::bsky::feed::get_author_feed::Error,
737 > {
738 let response = self
739 .xrpc
740 .send_xrpc::<
741 _,
742 (),
743 _,
744 _,
745 >(
746 &atrium_xrpc::XrpcRequest {
747 method: http::Method::GET,
748 nsid: crate::app::bsky::feed::get_author_feed::NSID.into(),
749 parameters: Some(params),
750 input: None,
751 encoding: None,
752 },
753 )
754 .await?;
755 match response {
756 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
757 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
758 }
759 }
760 pub async fn get_feed(
762 &self,
763 params: crate::app::bsky::feed::get_feed::Parameters,
764 ) -> atrium_xrpc::Result<
765 crate::app::bsky::feed::get_feed::Output,
766 crate::app::bsky::feed::get_feed::Error,
767 > {
768 let response = self
769 .xrpc
770 .send_xrpc::<
771 _,
772 (),
773 _,
774 _,
775 >(
776 &atrium_xrpc::XrpcRequest {
777 method: http::Method::GET,
778 nsid: crate::app::bsky::feed::get_feed::NSID.into(),
779 parameters: Some(params),
780 input: None,
781 encoding: None,
782 },
783 )
784 .await?;
785 match response {
786 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
787 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
788 }
789 }
790 pub async fn get_feed_generator(
792 &self,
793 params: crate::app::bsky::feed::get_feed_generator::Parameters,
794 ) -> atrium_xrpc::Result<
795 crate::app::bsky::feed::get_feed_generator::Output,
796 crate::app::bsky::feed::get_feed_generator::Error,
797 > {
798 let response = self
799 .xrpc
800 .send_xrpc::<
801 _,
802 (),
803 _,
804 _,
805 >(
806 &atrium_xrpc::XrpcRequest {
807 method: http::Method::GET,
808 nsid: crate::app::bsky::feed::get_feed_generator::NSID.into(),
809 parameters: Some(params),
810 input: None,
811 encoding: None,
812 },
813 )
814 .await?;
815 match response {
816 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
817 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
818 }
819 }
820 pub async fn get_feed_generators(
822 &self,
823 params: crate::app::bsky::feed::get_feed_generators::Parameters,
824 ) -> atrium_xrpc::Result<
825 crate::app::bsky::feed::get_feed_generators::Output,
826 crate::app::bsky::feed::get_feed_generators::Error,
827 > {
828 let response = self
829 .xrpc
830 .send_xrpc::<
831 _,
832 (),
833 _,
834 _,
835 >(
836 &atrium_xrpc::XrpcRequest {
837 method: http::Method::GET,
838 nsid: crate::app::bsky::feed::get_feed_generators::NSID.into(),
839 parameters: Some(params),
840 input: None,
841 encoding: None,
842 },
843 )
844 .await?;
845 match response {
846 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
847 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
848 }
849 }
850 pub async fn get_feed_skeleton(
852 &self,
853 params: crate::app::bsky::feed::get_feed_skeleton::Parameters,
854 ) -> atrium_xrpc::Result<
855 crate::app::bsky::feed::get_feed_skeleton::Output,
856 crate::app::bsky::feed::get_feed_skeleton::Error,
857 > {
858 let response = self
859 .xrpc
860 .send_xrpc::<
861 _,
862 (),
863 _,
864 _,
865 >(
866 &atrium_xrpc::XrpcRequest {
867 method: http::Method::GET,
868 nsid: crate::app::bsky::feed::get_feed_skeleton::NSID.into(),
869 parameters: Some(params),
870 input: None,
871 encoding: None,
872 },
873 )
874 .await?;
875 match response {
876 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
877 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
878 }
879 }
880 pub async fn get_likes(
882 &self,
883 params: crate::app::bsky::feed::get_likes::Parameters,
884 ) -> atrium_xrpc::Result<
885 crate::app::bsky::feed::get_likes::Output,
886 crate::app::bsky::feed::get_likes::Error,
887 > {
888 let response = self
889 .xrpc
890 .send_xrpc::<
891 _,
892 (),
893 _,
894 _,
895 >(
896 &atrium_xrpc::XrpcRequest {
897 method: http::Method::GET,
898 nsid: crate::app::bsky::feed::get_likes::NSID.into(),
899 parameters: Some(params),
900 input: None,
901 encoding: None,
902 },
903 )
904 .await?;
905 match response {
906 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
907 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
908 }
909 }
910 pub async fn get_list_feed(
912 &self,
913 params: crate::app::bsky::feed::get_list_feed::Parameters,
914 ) -> atrium_xrpc::Result<
915 crate::app::bsky::feed::get_list_feed::Output,
916 crate::app::bsky::feed::get_list_feed::Error,
917 > {
918 let response = self
919 .xrpc
920 .send_xrpc::<
921 _,
922 (),
923 _,
924 _,
925 >(
926 &atrium_xrpc::XrpcRequest {
927 method: http::Method::GET,
928 nsid: crate::app::bsky::feed::get_list_feed::NSID.into(),
929 parameters: Some(params),
930 input: None,
931 encoding: None,
932 },
933 )
934 .await?;
935 match response {
936 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
937 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
938 }
939 }
940 pub async fn get_post_thread(
942 &self,
943 params: crate::app::bsky::feed::get_post_thread::Parameters,
944 ) -> atrium_xrpc::Result<
945 crate::app::bsky::feed::get_post_thread::Output,
946 crate::app::bsky::feed::get_post_thread::Error,
947 > {
948 let response = self
949 .xrpc
950 .send_xrpc::<
951 _,
952 (),
953 _,
954 _,
955 >(
956 &atrium_xrpc::XrpcRequest {
957 method: http::Method::GET,
958 nsid: crate::app::bsky::feed::get_post_thread::NSID.into(),
959 parameters: Some(params),
960 input: None,
961 encoding: None,
962 },
963 )
964 .await?;
965 match response {
966 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
967 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
968 }
969 }
970 pub async fn get_posts(
972 &self,
973 params: crate::app::bsky::feed::get_posts::Parameters,
974 ) -> atrium_xrpc::Result<
975 crate::app::bsky::feed::get_posts::Output,
976 crate::app::bsky::feed::get_posts::Error,
977 > {
978 let response = self
979 .xrpc
980 .send_xrpc::<
981 _,
982 (),
983 _,
984 _,
985 >(
986 &atrium_xrpc::XrpcRequest {
987 method: http::Method::GET,
988 nsid: crate::app::bsky::feed::get_posts::NSID.into(),
989 parameters: Some(params),
990 input: None,
991 encoding: None,
992 },
993 )
994 .await?;
995 match response {
996 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
997 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
998 }
999 }
1000 pub async fn get_quotes(
1002 &self,
1003 params: crate::app::bsky::feed::get_quotes::Parameters,
1004 ) -> atrium_xrpc::Result<
1005 crate::app::bsky::feed::get_quotes::Output,
1006 crate::app::bsky::feed::get_quotes::Error,
1007 > {
1008 let response = self
1009 .xrpc
1010 .send_xrpc::<
1011 _,
1012 (),
1013 _,
1014 _,
1015 >(
1016 &atrium_xrpc::XrpcRequest {
1017 method: http::Method::GET,
1018 nsid: crate::app::bsky::feed::get_quotes::NSID.into(),
1019 parameters: Some(params),
1020 input: None,
1021 encoding: None,
1022 },
1023 )
1024 .await?;
1025 match response {
1026 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1027 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1028 }
1029 }
1030 pub async fn get_reposted_by(
1032 &self,
1033 params: crate::app::bsky::feed::get_reposted_by::Parameters,
1034 ) -> atrium_xrpc::Result<
1035 crate::app::bsky::feed::get_reposted_by::Output,
1036 crate::app::bsky::feed::get_reposted_by::Error,
1037 > {
1038 let response = self
1039 .xrpc
1040 .send_xrpc::<
1041 _,
1042 (),
1043 _,
1044 _,
1045 >(
1046 &atrium_xrpc::XrpcRequest {
1047 method: http::Method::GET,
1048 nsid: crate::app::bsky::feed::get_reposted_by::NSID.into(),
1049 parameters: Some(params),
1050 input: None,
1051 encoding: None,
1052 },
1053 )
1054 .await?;
1055 match response {
1056 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1057 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1058 }
1059 }
1060 pub async fn get_suggested_feeds(
1062 &self,
1063 params: crate::app::bsky::feed::get_suggested_feeds::Parameters,
1064 ) -> atrium_xrpc::Result<
1065 crate::app::bsky::feed::get_suggested_feeds::Output,
1066 crate::app::bsky::feed::get_suggested_feeds::Error,
1067 > {
1068 let response = self
1069 .xrpc
1070 .send_xrpc::<
1071 _,
1072 (),
1073 _,
1074 _,
1075 >(
1076 &atrium_xrpc::XrpcRequest {
1077 method: http::Method::GET,
1078 nsid: crate::app::bsky::feed::get_suggested_feeds::NSID.into(),
1079 parameters: Some(params),
1080 input: None,
1081 encoding: None,
1082 },
1083 )
1084 .await?;
1085 match response {
1086 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1087 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1088 }
1089 }
1090 pub async fn get_timeline(
1092 &self,
1093 params: crate::app::bsky::feed::get_timeline::Parameters,
1094 ) -> atrium_xrpc::Result<
1095 crate::app::bsky::feed::get_timeline::Output,
1096 crate::app::bsky::feed::get_timeline::Error,
1097 > {
1098 let response = self
1099 .xrpc
1100 .send_xrpc::<
1101 _,
1102 (),
1103 _,
1104 _,
1105 >(
1106 &atrium_xrpc::XrpcRequest {
1107 method: http::Method::GET,
1108 nsid: crate::app::bsky::feed::get_timeline::NSID.into(),
1109 parameters: Some(params),
1110 input: None,
1111 encoding: None,
1112 },
1113 )
1114 .await?;
1115 match response {
1116 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1117 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1118 }
1119 }
1120 pub async fn search_posts(
1122 &self,
1123 params: crate::app::bsky::feed::search_posts::Parameters,
1124 ) -> atrium_xrpc::Result<
1125 crate::app::bsky::feed::search_posts::Output,
1126 crate::app::bsky::feed::search_posts::Error,
1127 > {
1128 let response = self
1129 .xrpc
1130 .send_xrpc::<
1131 _,
1132 (),
1133 _,
1134 _,
1135 >(
1136 &atrium_xrpc::XrpcRequest {
1137 method: http::Method::GET,
1138 nsid: crate::app::bsky::feed::search_posts::NSID.into(),
1139 parameters: Some(params),
1140 input: None,
1141 encoding: None,
1142 },
1143 )
1144 .await?;
1145 match response {
1146 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1147 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1148 }
1149 }
1150 pub async fn send_interactions(
1152 &self,
1153 input: crate::app::bsky::feed::send_interactions::Input,
1154 ) -> atrium_xrpc::Result<
1155 crate::app::bsky::feed::send_interactions::Output,
1156 crate::app::bsky::feed::send_interactions::Error,
1157 > {
1158 let response = self
1159 .xrpc
1160 .send_xrpc::<
1161 (),
1162 _,
1163 _,
1164 _,
1165 >(
1166 &atrium_xrpc::XrpcRequest {
1167 method: http::Method::POST,
1168 nsid: crate::app::bsky::feed::send_interactions::NSID.into(),
1169 parameters: None,
1170 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1171 encoding: Some(String::from("application/json")),
1172 },
1173 )
1174 .await?;
1175 match response {
1176 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1177 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1178 }
1179 }
1180}
1181#[cfg(feature = "namespace-appbsky")]
1182impl<T> app::bsky::graph::Service<T>
1183where
1184 T: atrium_xrpc::XrpcClient + Send + Sync,
1185{
1186 #[allow(unused_variables)]
1187 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
1188 Self {
1189 xrpc,
1190 _phantom: core::marker::PhantomData,
1191 }
1192 }
1193 pub async fn get_actor_starter_packs(
1195 &self,
1196 params: crate::app::bsky::graph::get_actor_starter_packs::Parameters,
1197 ) -> atrium_xrpc::Result<
1198 crate::app::bsky::graph::get_actor_starter_packs::Output,
1199 crate::app::bsky::graph::get_actor_starter_packs::Error,
1200 > {
1201 let response = self
1202 .xrpc
1203 .send_xrpc::<
1204 _,
1205 (),
1206 _,
1207 _,
1208 >(
1209 &atrium_xrpc::XrpcRequest {
1210 method: http::Method::GET,
1211 nsid: crate::app::bsky::graph::get_actor_starter_packs::NSID.into(),
1212 parameters: Some(params),
1213 input: None,
1214 encoding: None,
1215 },
1216 )
1217 .await?;
1218 match response {
1219 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1220 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1221 }
1222 }
1223 pub async fn get_blocks(
1225 &self,
1226 params: crate::app::bsky::graph::get_blocks::Parameters,
1227 ) -> atrium_xrpc::Result<
1228 crate::app::bsky::graph::get_blocks::Output,
1229 crate::app::bsky::graph::get_blocks::Error,
1230 > {
1231 let response = self
1232 .xrpc
1233 .send_xrpc::<
1234 _,
1235 (),
1236 _,
1237 _,
1238 >(
1239 &atrium_xrpc::XrpcRequest {
1240 method: http::Method::GET,
1241 nsid: crate::app::bsky::graph::get_blocks::NSID.into(),
1242 parameters: Some(params),
1243 input: None,
1244 encoding: None,
1245 },
1246 )
1247 .await?;
1248 match response {
1249 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1250 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1251 }
1252 }
1253 pub async fn get_followers(
1255 &self,
1256 params: crate::app::bsky::graph::get_followers::Parameters,
1257 ) -> atrium_xrpc::Result<
1258 crate::app::bsky::graph::get_followers::Output,
1259 crate::app::bsky::graph::get_followers::Error,
1260 > {
1261 let response = self
1262 .xrpc
1263 .send_xrpc::<
1264 _,
1265 (),
1266 _,
1267 _,
1268 >(
1269 &atrium_xrpc::XrpcRequest {
1270 method: http::Method::GET,
1271 nsid: crate::app::bsky::graph::get_followers::NSID.into(),
1272 parameters: Some(params),
1273 input: None,
1274 encoding: None,
1275 },
1276 )
1277 .await?;
1278 match response {
1279 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1280 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1281 }
1282 }
1283 pub async fn get_follows(
1285 &self,
1286 params: crate::app::bsky::graph::get_follows::Parameters,
1287 ) -> atrium_xrpc::Result<
1288 crate::app::bsky::graph::get_follows::Output,
1289 crate::app::bsky::graph::get_follows::Error,
1290 > {
1291 let response = self
1292 .xrpc
1293 .send_xrpc::<
1294 _,
1295 (),
1296 _,
1297 _,
1298 >(
1299 &atrium_xrpc::XrpcRequest {
1300 method: http::Method::GET,
1301 nsid: crate::app::bsky::graph::get_follows::NSID.into(),
1302 parameters: Some(params),
1303 input: None,
1304 encoding: None,
1305 },
1306 )
1307 .await?;
1308 match response {
1309 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1310 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1311 }
1312 }
1313 pub async fn get_known_followers(
1315 &self,
1316 params: crate::app::bsky::graph::get_known_followers::Parameters,
1317 ) -> atrium_xrpc::Result<
1318 crate::app::bsky::graph::get_known_followers::Output,
1319 crate::app::bsky::graph::get_known_followers::Error,
1320 > {
1321 let response = self
1322 .xrpc
1323 .send_xrpc::<
1324 _,
1325 (),
1326 _,
1327 _,
1328 >(
1329 &atrium_xrpc::XrpcRequest {
1330 method: http::Method::GET,
1331 nsid: crate::app::bsky::graph::get_known_followers::NSID.into(),
1332 parameters: Some(params),
1333 input: None,
1334 encoding: None,
1335 },
1336 )
1337 .await?;
1338 match response {
1339 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1340 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1341 }
1342 }
1343 pub async fn get_list(
1345 &self,
1346 params: crate::app::bsky::graph::get_list::Parameters,
1347 ) -> atrium_xrpc::Result<
1348 crate::app::bsky::graph::get_list::Output,
1349 crate::app::bsky::graph::get_list::Error,
1350 > {
1351 let response = self
1352 .xrpc
1353 .send_xrpc::<
1354 _,
1355 (),
1356 _,
1357 _,
1358 >(
1359 &atrium_xrpc::XrpcRequest {
1360 method: http::Method::GET,
1361 nsid: crate::app::bsky::graph::get_list::NSID.into(),
1362 parameters: Some(params),
1363 input: None,
1364 encoding: None,
1365 },
1366 )
1367 .await?;
1368 match response {
1369 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1370 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1371 }
1372 }
1373 pub async fn get_list_blocks(
1375 &self,
1376 params: crate::app::bsky::graph::get_list_blocks::Parameters,
1377 ) -> atrium_xrpc::Result<
1378 crate::app::bsky::graph::get_list_blocks::Output,
1379 crate::app::bsky::graph::get_list_blocks::Error,
1380 > {
1381 let response = self
1382 .xrpc
1383 .send_xrpc::<
1384 _,
1385 (),
1386 _,
1387 _,
1388 >(
1389 &atrium_xrpc::XrpcRequest {
1390 method: http::Method::GET,
1391 nsid: crate::app::bsky::graph::get_list_blocks::NSID.into(),
1392 parameters: Some(params),
1393 input: None,
1394 encoding: None,
1395 },
1396 )
1397 .await?;
1398 match response {
1399 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1400 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1401 }
1402 }
1403 pub async fn get_list_mutes(
1405 &self,
1406 params: crate::app::bsky::graph::get_list_mutes::Parameters,
1407 ) -> atrium_xrpc::Result<
1408 crate::app::bsky::graph::get_list_mutes::Output,
1409 crate::app::bsky::graph::get_list_mutes::Error,
1410 > {
1411 let response = self
1412 .xrpc
1413 .send_xrpc::<
1414 _,
1415 (),
1416 _,
1417 _,
1418 >(
1419 &atrium_xrpc::XrpcRequest {
1420 method: http::Method::GET,
1421 nsid: crate::app::bsky::graph::get_list_mutes::NSID.into(),
1422 parameters: Some(params),
1423 input: None,
1424 encoding: None,
1425 },
1426 )
1427 .await?;
1428 match response {
1429 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1430 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1431 }
1432 }
1433 pub async fn get_lists(
1435 &self,
1436 params: crate::app::bsky::graph::get_lists::Parameters,
1437 ) -> atrium_xrpc::Result<
1438 crate::app::bsky::graph::get_lists::Output,
1439 crate::app::bsky::graph::get_lists::Error,
1440 > {
1441 let response = self
1442 .xrpc
1443 .send_xrpc::<
1444 _,
1445 (),
1446 _,
1447 _,
1448 >(
1449 &atrium_xrpc::XrpcRequest {
1450 method: http::Method::GET,
1451 nsid: crate::app::bsky::graph::get_lists::NSID.into(),
1452 parameters: Some(params),
1453 input: None,
1454 encoding: None,
1455 },
1456 )
1457 .await?;
1458 match response {
1459 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1460 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1461 }
1462 }
1463 pub async fn get_mutes(
1465 &self,
1466 params: crate::app::bsky::graph::get_mutes::Parameters,
1467 ) -> atrium_xrpc::Result<
1468 crate::app::bsky::graph::get_mutes::Output,
1469 crate::app::bsky::graph::get_mutes::Error,
1470 > {
1471 let response = self
1472 .xrpc
1473 .send_xrpc::<
1474 _,
1475 (),
1476 _,
1477 _,
1478 >(
1479 &atrium_xrpc::XrpcRequest {
1480 method: http::Method::GET,
1481 nsid: crate::app::bsky::graph::get_mutes::NSID.into(),
1482 parameters: Some(params),
1483 input: None,
1484 encoding: None,
1485 },
1486 )
1487 .await?;
1488 match response {
1489 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1490 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1491 }
1492 }
1493 pub async fn get_relationships(
1495 &self,
1496 params: crate::app::bsky::graph::get_relationships::Parameters,
1497 ) -> atrium_xrpc::Result<
1498 crate::app::bsky::graph::get_relationships::Output,
1499 crate::app::bsky::graph::get_relationships::Error,
1500 > {
1501 let response = self
1502 .xrpc
1503 .send_xrpc::<
1504 _,
1505 (),
1506 _,
1507 _,
1508 >(
1509 &atrium_xrpc::XrpcRequest {
1510 method: http::Method::GET,
1511 nsid: crate::app::bsky::graph::get_relationships::NSID.into(),
1512 parameters: Some(params),
1513 input: None,
1514 encoding: None,
1515 },
1516 )
1517 .await?;
1518 match response {
1519 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1520 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1521 }
1522 }
1523 pub async fn get_starter_pack(
1525 &self,
1526 params: crate::app::bsky::graph::get_starter_pack::Parameters,
1527 ) -> atrium_xrpc::Result<
1528 crate::app::bsky::graph::get_starter_pack::Output,
1529 crate::app::bsky::graph::get_starter_pack::Error,
1530 > {
1531 let response = self
1532 .xrpc
1533 .send_xrpc::<
1534 _,
1535 (),
1536 _,
1537 _,
1538 >(
1539 &atrium_xrpc::XrpcRequest {
1540 method: http::Method::GET,
1541 nsid: crate::app::bsky::graph::get_starter_pack::NSID.into(),
1542 parameters: Some(params),
1543 input: None,
1544 encoding: None,
1545 },
1546 )
1547 .await?;
1548 match response {
1549 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1550 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1551 }
1552 }
1553 pub async fn get_starter_packs(
1555 &self,
1556 params: crate::app::bsky::graph::get_starter_packs::Parameters,
1557 ) -> atrium_xrpc::Result<
1558 crate::app::bsky::graph::get_starter_packs::Output,
1559 crate::app::bsky::graph::get_starter_packs::Error,
1560 > {
1561 let response = self
1562 .xrpc
1563 .send_xrpc::<
1564 _,
1565 (),
1566 _,
1567 _,
1568 >(
1569 &atrium_xrpc::XrpcRequest {
1570 method: http::Method::GET,
1571 nsid: crate::app::bsky::graph::get_starter_packs::NSID.into(),
1572 parameters: Some(params),
1573 input: None,
1574 encoding: None,
1575 },
1576 )
1577 .await?;
1578 match response {
1579 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1580 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1581 }
1582 }
1583 pub async fn get_suggested_follows_by_actor(
1585 &self,
1586 params: crate::app::bsky::graph::get_suggested_follows_by_actor::Parameters,
1587 ) -> atrium_xrpc::Result<
1588 crate::app::bsky::graph::get_suggested_follows_by_actor::Output,
1589 crate::app::bsky::graph::get_suggested_follows_by_actor::Error,
1590 > {
1591 let response = self
1592 .xrpc
1593 .send_xrpc::<
1594 _,
1595 (),
1596 _,
1597 _,
1598 >(
1599 &atrium_xrpc::XrpcRequest {
1600 method: http::Method::GET,
1601 nsid: crate::app::bsky::graph::get_suggested_follows_by_actor::NSID
1602 .into(),
1603 parameters: Some(params),
1604 input: None,
1605 encoding: None,
1606 },
1607 )
1608 .await?;
1609 match response {
1610 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1611 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1612 }
1613 }
1614 pub async fn mute_actor(
1616 &self,
1617 input: crate::app::bsky::graph::mute_actor::Input,
1618 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_actor::Error> {
1619 let response = self
1620 .xrpc
1621 .send_xrpc::<
1622 (),
1623 _,
1624 (),
1625 _,
1626 >(
1627 &atrium_xrpc::XrpcRequest {
1628 method: http::Method::POST,
1629 nsid: crate::app::bsky::graph::mute_actor::NSID.into(),
1630 parameters: None,
1631 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1632 encoding: Some(String::from("application/json")),
1633 },
1634 )
1635 .await?;
1636 match response {
1637 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1638 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1639 }
1640 }
1641 pub async fn mute_actor_list(
1643 &self,
1644 input: crate::app::bsky::graph::mute_actor_list::Input,
1645 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_actor_list::Error> {
1646 let response = self
1647 .xrpc
1648 .send_xrpc::<
1649 (),
1650 _,
1651 (),
1652 _,
1653 >(
1654 &atrium_xrpc::XrpcRequest {
1655 method: http::Method::POST,
1656 nsid: crate::app::bsky::graph::mute_actor_list::NSID.into(),
1657 parameters: None,
1658 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1659 encoding: Some(String::from("application/json")),
1660 },
1661 )
1662 .await?;
1663 match response {
1664 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1665 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1666 }
1667 }
1668 pub async fn mute_thread(
1670 &self,
1671 input: crate::app::bsky::graph::mute_thread::Input,
1672 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::mute_thread::Error> {
1673 let response = self
1674 .xrpc
1675 .send_xrpc::<
1676 (),
1677 _,
1678 (),
1679 _,
1680 >(
1681 &atrium_xrpc::XrpcRequest {
1682 method: http::Method::POST,
1683 nsid: crate::app::bsky::graph::mute_thread::NSID.into(),
1684 parameters: None,
1685 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1686 encoding: Some(String::from("application/json")),
1687 },
1688 )
1689 .await?;
1690 match response {
1691 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1692 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1693 }
1694 }
1695 pub async fn search_starter_packs(
1697 &self,
1698 params: crate::app::bsky::graph::search_starter_packs::Parameters,
1699 ) -> atrium_xrpc::Result<
1700 crate::app::bsky::graph::search_starter_packs::Output,
1701 crate::app::bsky::graph::search_starter_packs::Error,
1702 > {
1703 let response = self
1704 .xrpc
1705 .send_xrpc::<
1706 _,
1707 (),
1708 _,
1709 _,
1710 >(
1711 &atrium_xrpc::XrpcRequest {
1712 method: http::Method::GET,
1713 nsid: crate::app::bsky::graph::search_starter_packs::NSID.into(),
1714 parameters: Some(params),
1715 input: None,
1716 encoding: None,
1717 },
1718 )
1719 .await?;
1720 match response {
1721 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1722 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1723 }
1724 }
1725 pub async fn unmute_actor(
1727 &self,
1728 input: crate::app::bsky::graph::unmute_actor::Input,
1729 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_actor::Error> {
1730 let response = self
1731 .xrpc
1732 .send_xrpc::<
1733 (),
1734 _,
1735 (),
1736 _,
1737 >(
1738 &atrium_xrpc::XrpcRequest {
1739 method: http::Method::POST,
1740 nsid: crate::app::bsky::graph::unmute_actor::NSID.into(),
1741 parameters: None,
1742 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1743 encoding: Some(String::from("application/json")),
1744 },
1745 )
1746 .await?;
1747 match response {
1748 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1749 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1750 }
1751 }
1752 pub async fn unmute_actor_list(
1754 &self,
1755 input: crate::app::bsky::graph::unmute_actor_list::Input,
1756 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_actor_list::Error> {
1757 let response = self
1758 .xrpc
1759 .send_xrpc::<
1760 (),
1761 _,
1762 (),
1763 _,
1764 >(
1765 &atrium_xrpc::XrpcRequest {
1766 method: http::Method::POST,
1767 nsid: crate::app::bsky::graph::unmute_actor_list::NSID.into(),
1768 parameters: None,
1769 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1770 encoding: Some(String::from("application/json")),
1771 },
1772 )
1773 .await?;
1774 match response {
1775 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1776 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1777 }
1778 }
1779 pub async fn unmute_thread(
1781 &self,
1782 input: crate::app::bsky::graph::unmute_thread::Input,
1783 ) -> atrium_xrpc::Result<(), crate::app::bsky::graph::unmute_thread::Error> {
1784 let response = self
1785 .xrpc
1786 .send_xrpc::<
1787 (),
1788 _,
1789 (),
1790 _,
1791 >(
1792 &atrium_xrpc::XrpcRequest {
1793 method: http::Method::POST,
1794 nsid: crate::app::bsky::graph::unmute_thread::NSID.into(),
1795 parameters: None,
1796 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1797 encoding: Some(String::from("application/json")),
1798 },
1799 )
1800 .await?;
1801 match response {
1802 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1803 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1804 }
1805 }
1806}
1807#[cfg(feature = "namespace-appbsky")]
1808impl<T> app::bsky::labeler::Service<T>
1809where
1810 T: atrium_xrpc::XrpcClient + Send + Sync,
1811{
1812 #[allow(unused_variables)]
1813 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
1814 Self {
1815 xrpc,
1816 _phantom: core::marker::PhantomData,
1817 }
1818 }
1819 pub async fn get_services(
1821 &self,
1822 params: crate::app::bsky::labeler::get_services::Parameters,
1823 ) -> atrium_xrpc::Result<
1824 crate::app::bsky::labeler::get_services::Output,
1825 crate::app::bsky::labeler::get_services::Error,
1826 > {
1827 let response = self
1828 .xrpc
1829 .send_xrpc::<
1830 _,
1831 (),
1832 _,
1833 _,
1834 >(
1835 &atrium_xrpc::XrpcRequest {
1836 method: http::Method::GET,
1837 nsid: crate::app::bsky::labeler::get_services::NSID.into(),
1838 parameters: Some(params),
1839 input: None,
1840 encoding: None,
1841 },
1842 )
1843 .await?;
1844 match response {
1845 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1846 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1847 }
1848 }
1849}
1850#[cfg(feature = "namespace-appbsky")]
1851impl<T> app::bsky::notification::Service<T>
1852where
1853 T: atrium_xrpc::XrpcClient + Send + Sync,
1854{
1855 #[allow(unused_variables)]
1856 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
1857 Self {
1858 xrpc,
1859 _phantom: core::marker::PhantomData,
1860 }
1861 }
1862 pub async fn get_unread_count(
1864 &self,
1865 params: crate::app::bsky::notification::get_unread_count::Parameters,
1866 ) -> atrium_xrpc::Result<
1867 crate::app::bsky::notification::get_unread_count::Output,
1868 crate::app::bsky::notification::get_unread_count::Error,
1869 > {
1870 let response = self
1871 .xrpc
1872 .send_xrpc::<
1873 _,
1874 (),
1875 _,
1876 _,
1877 >(
1878 &atrium_xrpc::XrpcRequest {
1879 method: http::Method::GET,
1880 nsid: crate::app::bsky::notification::get_unread_count::NSID.into(),
1881 parameters: Some(params),
1882 input: None,
1883 encoding: None,
1884 },
1885 )
1886 .await?;
1887 match response {
1888 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1889 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1890 }
1891 }
1892 pub async fn list_notifications(
1894 &self,
1895 params: crate::app::bsky::notification::list_notifications::Parameters,
1896 ) -> atrium_xrpc::Result<
1897 crate::app::bsky::notification::list_notifications::Output,
1898 crate::app::bsky::notification::list_notifications::Error,
1899 > {
1900 let response = self
1901 .xrpc
1902 .send_xrpc::<
1903 _,
1904 (),
1905 _,
1906 _,
1907 >(
1908 &atrium_xrpc::XrpcRequest {
1909 method: http::Method::GET,
1910 nsid: crate::app::bsky::notification::list_notifications::NSID
1911 .into(),
1912 parameters: Some(params),
1913 input: None,
1914 encoding: None,
1915 },
1916 )
1917 .await?;
1918 match response {
1919 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
1920 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1921 }
1922 }
1923 pub async fn put_preferences(
1925 &self,
1926 input: crate::app::bsky::notification::put_preferences::Input,
1927 ) -> atrium_xrpc::Result<
1928 (),
1929 crate::app::bsky::notification::put_preferences::Error,
1930 > {
1931 let response = self
1932 .xrpc
1933 .send_xrpc::<
1934 (),
1935 _,
1936 (),
1937 _,
1938 >(
1939 &atrium_xrpc::XrpcRequest {
1940 method: http::Method::POST,
1941 nsid: crate::app::bsky::notification::put_preferences::NSID.into(),
1942 parameters: None,
1943 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1944 encoding: Some(String::from("application/json")),
1945 },
1946 )
1947 .await?;
1948 match response {
1949 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1950 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1951 }
1952 }
1953 pub async fn register_push(
1955 &self,
1956 input: crate::app::bsky::notification::register_push::Input,
1957 ) -> atrium_xrpc::Result<(), crate::app::bsky::notification::register_push::Error> {
1958 let response = self
1959 .xrpc
1960 .send_xrpc::<
1961 (),
1962 _,
1963 (),
1964 _,
1965 >(
1966 &atrium_xrpc::XrpcRequest {
1967 method: http::Method::POST,
1968 nsid: crate::app::bsky::notification::register_push::NSID.into(),
1969 parameters: None,
1970 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1971 encoding: Some(String::from("application/json")),
1972 },
1973 )
1974 .await?;
1975 match response {
1976 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
1977 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
1978 }
1979 }
1980 pub async fn update_seen(
1982 &self,
1983 input: crate::app::bsky::notification::update_seen::Input,
1984 ) -> atrium_xrpc::Result<(), crate::app::bsky::notification::update_seen::Error> {
1985 let response = self
1986 .xrpc
1987 .send_xrpc::<
1988 (),
1989 _,
1990 (),
1991 _,
1992 >(
1993 &atrium_xrpc::XrpcRequest {
1994 method: http::Method::POST,
1995 nsid: crate::app::bsky::notification::update_seen::NSID.into(),
1996 parameters: None,
1997 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
1998 encoding: Some(String::from("application/json")),
1999 },
2000 )
2001 .await?;
2002 match response {
2003 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
2004 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2005 }
2006 }
2007}
2008#[cfg(feature = "namespace-appbsky")]
2009impl<T> app::bsky::unspecced::Service<T>
2010where
2011 T: atrium_xrpc::XrpcClient + Send + Sync,
2012{
2013 #[allow(unused_variables)]
2014 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2015 Self {
2016 xrpc,
2017 _phantom: core::marker::PhantomData,
2018 }
2019 }
2020 pub async fn get_config(
2022 &self,
2023 ) -> atrium_xrpc::Result<
2024 crate::app::bsky::unspecced::get_config::Output,
2025 crate::app::bsky::unspecced::get_config::Error,
2026 > {
2027 let response = self
2028 .xrpc
2029 .send_xrpc::<
2030 (),
2031 (),
2032 _,
2033 _,
2034 >(
2035 &atrium_xrpc::XrpcRequest {
2036 method: http::Method::GET,
2037 nsid: crate::app::bsky::unspecced::get_config::NSID.into(),
2038 parameters: None,
2039 input: None,
2040 encoding: None,
2041 },
2042 )
2043 .await?;
2044 match response {
2045 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2046 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2047 }
2048 }
2049 pub async fn get_popular_feed_generators(
2051 &self,
2052 params: crate::app::bsky::unspecced::get_popular_feed_generators::Parameters,
2053 ) -> atrium_xrpc::Result<
2054 crate::app::bsky::unspecced::get_popular_feed_generators::Output,
2055 crate::app::bsky::unspecced::get_popular_feed_generators::Error,
2056 > {
2057 let response = self
2058 .xrpc
2059 .send_xrpc::<
2060 _,
2061 (),
2062 _,
2063 _,
2064 >(
2065 &atrium_xrpc::XrpcRequest {
2066 method: http::Method::GET,
2067 nsid: crate::app::bsky::unspecced::get_popular_feed_generators::NSID
2068 .into(),
2069 parameters: Some(params),
2070 input: None,
2071 encoding: None,
2072 },
2073 )
2074 .await?;
2075 match response {
2076 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2077 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2078 }
2079 }
2080 pub async fn get_suggestions_skeleton(
2082 &self,
2083 params: crate::app::bsky::unspecced::get_suggestions_skeleton::Parameters,
2084 ) -> atrium_xrpc::Result<
2085 crate::app::bsky::unspecced::get_suggestions_skeleton::Output,
2086 crate::app::bsky::unspecced::get_suggestions_skeleton::Error,
2087 > {
2088 let response = self
2089 .xrpc
2090 .send_xrpc::<
2091 _,
2092 (),
2093 _,
2094 _,
2095 >(
2096 &atrium_xrpc::XrpcRequest {
2097 method: http::Method::GET,
2098 nsid: crate::app::bsky::unspecced::get_suggestions_skeleton::NSID
2099 .into(),
2100 parameters: Some(params),
2101 input: None,
2102 encoding: None,
2103 },
2104 )
2105 .await?;
2106 match response {
2107 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2108 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2109 }
2110 }
2111 pub async fn get_tagged_suggestions(
2113 &self,
2114 params: crate::app::bsky::unspecced::get_tagged_suggestions::Parameters,
2115 ) -> atrium_xrpc::Result<
2116 crate::app::bsky::unspecced::get_tagged_suggestions::Output,
2117 crate::app::bsky::unspecced::get_tagged_suggestions::Error,
2118 > {
2119 let response = self
2120 .xrpc
2121 .send_xrpc::<
2122 _,
2123 (),
2124 _,
2125 _,
2126 >(
2127 &atrium_xrpc::XrpcRequest {
2128 method: http::Method::GET,
2129 nsid: crate::app::bsky::unspecced::get_tagged_suggestions::NSID
2130 .into(),
2131 parameters: Some(params),
2132 input: None,
2133 encoding: None,
2134 },
2135 )
2136 .await?;
2137 match response {
2138 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2139 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2140 }
2141 }
2142 pub async fn get_trending_topics(
2144 &self,
2145 params: crate::app::bsky::unspecced::get_trending_topics::Parameters,
2146 ) -> atrium_xrpc::Result<
2147 crate::app::bsky::unspecced::get_trending_topics::Output,
2148 crate::app::bsky::unspecced::get_trending_topics::Error,
2149 > {
2150 let response = self
2151 .xrpc
2152 .send_xrpc::<
2153 _,
2154 (),
2155 _,
2156 _,
2157 >(
2158 &atrium_xrpc::XrpcRequest {
2159 method: http::Method::GET,
2160 nsid: crate::app::bsky::unspecced::get_trending_topics::NSID.into(),
2161 parameters: Some(params),
2162 input: None,
2163 encoding: None,
2164 },
2165 )
2166 .await?;
2167 match response {
2168 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2169 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2170 }
2171 }
2172 pub async fn search_actors_skeleton(
2174 &self,
2175 params: crate::app::bsky::unspecced::search_actors_skeleton::Parameters,
2176 ) -> atrium_xrpc::Result<
2177 crate::app::bsky::unspecced::search_actors_skeleton::Output,
2178 crate::app::bsky::unspecced::search_actors_skeleton::Error,
2179 > {
2180 let response = self
2181 .xrpc
2182 .send_xrpc::<
2183 _,
2184 (),
2185 _,
2186 _,
2187 >(
2188 &atrium_xrpc::XrpcRequest {
2189 method: http::Method::GET,
2190 nsid: crate::app::bsky::unspecced::search_actors_skeleton::NSID
2191 .into(),
2192 parameters: Some(params),
2193 input: None,
2194 encoding: None,
2195 },
2196 )
2197 .await?;
2198 match response {
2199 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2200 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2201 }
2202 }
2203 pub async fn search_posts_skeleton(
2205 &self,
2206 params: crate::app::bsky::unspecced::search_posts_skeleton::Parameters,
2207 ) -> atrium_xrpc::Result<
2208 crate::app::bsky::unspecced::search_posts_skeleton::Output,
2209 crate::app::bsky::unspecced::search_posts_skeleton::Error,
2210 > {
2211 let response = self
2212 .xrpc
2213 .send_xrpc::<
2214 _,
2215 (),
2216 _,
2217 _,
2218 >(
2219 &atrium_xrpc::XrpcRequest {
2220 method: http::Method::GET,
2221 nsid: crate::app::bsky::unspecced::search_posts_skeleton::NSID
2222 .into(),
2223 parameters: Some(params),
2224 input: None,
2225 encoding: None,
2226 },
2227 )
2228 .await?;
2229 match response {
2230 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2231 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2232 }
2233 }
2234 pub async fn search_starter_packs_skeleton(
2236 &self,
2237 params: crate::app::bsky::unspecced::search_starter_packs_skeleton::Parameters,
2238 ) -> atrium_xrpc::Result<
2239 crate::app::bsky::unspecced::search_starter_packs_skeleton::Output,
2240 crate::app::bsky::unspecced::search_starter_packs_skeleton::Error,
2241 > {
2242 let response = self
2243 .xrpc
2244 .send_xrpc::<
2245 _,
2246 (),
2247 _,
2248 _,
2249 >(
2250 &atrium_xrpc::XrpcRequest {
2251 method: http::Method::GET,
2252 nsid: crate::app::bsky::unspecced::search_starter_packs_skeleton::NSID
2253 .into(),
2254 parameters: Some(params),
2255 input: None,
2256 encoding: None,
2257 },
2258 )
2259 .await?;
2260 match response {
2261 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2262 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2263 }
2264 }
2265}
2266#[cfg(feature = "namespace-appbsky")]
2267impl<T> app::bsky::video::Service<T>
2268where
2269 T: atrium_xrpc::XrpcClient + Send + Sync,
2270{
2271 #[allow(unused_variables)]
2272 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2273 Self {
2274 xrpc,
2275 _phantom: core::marker::PhantomData,
2276 }
2277 }
2278 pub async fn get_job_status(
2280 &self,
2281 params: crate::app::bsky::video::get_job_status::Parameters,
2282 ) -> atrium_xrpc::Result<
2283 crate::app::bsky::video::get_job_status::Output,
2284 crate::app::bsky::video::get_job_status::Error,
2285 > {
2286 let response = self
2287 .xrpc
2288 .send_xrpc::<
2289 _,
2290 (),
2291 _,
2292 _,
2293 >(
2294 &atrium_xrpc::XrpcRequest {
2295 method: http::Method::GET,
2296 nsid: crate::app::bsky::video::get_job_status::NSID.into(),
2297 parameters: Some(params),
2298 input: None,
2299 encoding: None,
2300 },
2301 )
2302 .await?;
2303 match response {
2304 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2305 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2306 }
2307 }
2308 pub async fn get_upload_limits(
2310 &self,
2311 ) -> atrium_xrpc::Result<
2312 crate::app::bsky::video::get_upload_limits::Output,
2313 crate::app::bsky::video::get_upload_limits::Error,
2314 > {
2315 let response = self
2316 .xrpc
2317 .send_xrpc::<
2318 (),
2319 (),
2320 _,
2321 _,
2322 >(
2323 &atrium_xrpc::XrpcRequest {
2324 method: http::Method::GET,
2325 nsid: crate::app::bsky::video::get_upload_limits::NSID.into(),
2326 parameters: None,
2327 input: None,
2328 encoding: None,
2329 },
2330 )
2331 .await?;
2332 match response {
2333 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2334 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2335 }
2336 }
2337 pub async fn upload_video(
2339 &self,
2340 input: Vec<u8>,
2341 ) -> atrium_xrpc::Result<
2342 crate::app::bsky::video::upload_video::Output,
2343 crate::app::bsky::video::upload_video::Error,
2344 > {
2345 let response = self
2346 .xrpc
2347 .send_xrpc::<
2348 (),
2349 Vec<u8>,
2350 _,
2351 _,
2352 >(
2353 &atrium_xrpc::XrpcRequest {
2354 method: http::Method::POST,
2355 nsid: crate::app::bsky::video::upload_video::NSID.into(),
2356 parameters: None,
2357 input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
2358 encoding: Some(String::from("video/mp4")),
2359 },
2360 )
2361 .await?;
2362 match response {
2363 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2364 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2365 }
2366 }
2367}
2368impl<T> chat::Service<T>
2369where
2370 T: atrium_xrpc::XrpcClient + Send + Sync,
2371{
2372 #[allow(unused_variables)]
2373 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2374 Self {
2375 #[cfg(feature = "namespace-chatbsky")]
2376 bsky: chat::bsky::Service::new(std::sync::Arc::clone(&xrpc)),
2377 _phantom: core::marker::PhantomData,
2378 }
2379 }
2380}
2381#[cfg(feature = "namespace-chatbsky")]
2382impl<T> chat::bsky::Service<T>
2383where
2384 T: atrium_xrpc::XrpcClient + Send + Sync,
2385{
2386 #[allow(unused_variables)]
2387 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2388 Self {
2389 actor: chat::bsky::actor::Service::new(std::sync::Arc::clone(&xrpc)),
2390 convo: chat::bsky::convo::Service::new(std::sync::Arc::clone(&xrpc)),
2391 moderation: chat::bsky::moderation::Service::new(
2392 std::sync::Arc::clone(&xrpc),
2393 ),
2394 _phantom: core::marker::PhantomData,
2395 }
2396 }
2397}
2398#[cfg(feature = "namespace-chatbsky")]
2399impl<T> chat::bsky::actor::Service<T>
2400where
2401 T: atrium_xrpc::XrpcClient + Send + Sync,
2402{
2403 #[allow(unused_variables)]
2404 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2405 Self {
2406 xrpc,
2407 _phantom: core::marker::PhantomData,
2408 }
2409 }
2410 pub async fn delete_account(
2411 &self,
2412 ) -> atrium_xrpc::Result<
2413 crate::chat::bsky::actor::delete_account::Output,
2414 crate::chat::bsky::actor::delete_account::Error,
2415 > {
2416 let response = self
2417 .xrpc
2418 .send_xrpc::<
2419 (),
2420 (),
2421 _,
2422 _,
2423 >(
2424 &atrium_xrpc::XrpcRequest {
2425 method: http::Method::POST,
2426 nsid: crate::chat::bsky::actor::delete_account::NSID.into(),
2427 parameters: None,
2428 input: None,
2429 encoding: None,
2430 },
2431 )
2432 .await?;
2433 match response {
2434 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2435 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2436 }
2437 }
2438 pub async fn export_account_data(
2439 &self,
2440 ) -> atrium_xrpc::Result<
2441 Vec<u8>,
2442 crate::chat::bsky::actor::export_account_data::Error,
2443 > {
2444 let response = self
2445 .xrpc
2446 .send_xrpc::<
2447 (),
2448 (),
2449 (),
2450 _,
2451 >(
2452 &atrium_xrpc::XrpcRequest {
2453 method: http::Method::GET,
2454 nsid: crate::chat::bsky::actor::export_account_data::NSID.into(),
2455 parameters: None,
2456 input: None,
2457 encoding: None,
2458 },
2459 )
2460 .await?;
2461 match response {
2462 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
2463 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2464 }
2465 }
2466}
2467#[cfg(feature = "namespace-chatbsky")]
2468impl<T> chat::bsky::convo::Service<T>
2469where
2470 T: atrium_xrpc::XrpcClient + Send + Sync,
2471{
2472 #[allow(unused_variables)]
2473 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2474 Self {
2475 xrpc,
2476 _phantom: core::marker::PhantomData,
2477 }
2478 }
2479 pub async fn accept_convo(
2480 &self,
2481 input: crate::chat::bsky::convo::accept_convo::Input,
2482 ) -> atrium_xrpc::Result<
2483 crate::chat::bsky::convo::accept_convo::Output,
2484 crate::chat::bsky::convo::accept_convo::Error,
2485 > {
2486 let response = self
2487 .xrpc
2488 .send_xrpc::<
2489 (),
2490 _,
2491 _,
2492 _,
2493 >(
2494 &atrium_xrpc::XrpcRequest {
2495 method: http::Method::POST,
2496 nsid: crate::chat::bsky::convo::accept_convo::NSID.into(),
2497 parameters: None,
2498 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2499 encoding: Some(String::from("application/json")),
2500 },
2501 )
2502 .await?;
2503 match response {
2504 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2505 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2506 }
2507 }
2508 pub async fn add_reaction(
2510 &self,
2511 input: crate::chat::bsky::convo::add_reaction::Input,
2512 ) -> atrium_xrpc::Result<
2513 crate::chat::bsky::convo::add_reaction::Output,
2514 crate::chat::bsky::convo::add_reaction::Error,
2515 > {
2516 let response = self
2517 .xrpc
2518 .send_xrpc::<
2519 (),
2520 _,
2521 _,
2522 _,
2523 >(
2524 &atrium_xrpc::XrpcRequest {
2525 method: http::Method::POST,
2526 nsid: crate::chat::bsky::convo::add_reaction::NSID.into(),
2527 parameters: None,
2528 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2529 encoding: Some(String::from("application/json")),
2530 },
2531 )
2532 .await?;
2533 match response {
2534 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2535 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2536 }
2537 }
2538 pub async fn delete_message_for_self(
2539 &self,
2540 input: crate::chat::bsky::convo::delete_message_for_self::Input,
2541 ) -> atrium_xrpc::Result<
2542 crate::chat::bsky::convo::delete_message_for_self::Output,
2543 crate::chat::bsky::convo::delete_message_for_self::Error,
2544 > {
2545 let response = self
2546 .xrpc
2547 .send_xrpc::<
2548 (),
2549 _,
2550 _,
2551 _,
2552 >(
2553 &atrium_xrpc::XrpcRequest {
2554 method: http::Method::POST,
2555 nsid: crate::chat::bsky::convo::delete_message_for_self::NSID.into(),
2556 parameters: None,
2557 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2558 encoding: Some(String::from("application/json")),
2559 },
2560 )
2561 .await?;
2562 match response {
2563 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2564 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2565 }
2566 }
2567 pub async fn get_convo(
2568 &self,
2569 params: crate::chat::bsky::convo::get_convo::Parameters,
2570 ) -> atrium_xrpc::Result<
2571 crate::chat::bsky::convo::get_convo::Output,
2572 crate::chat::bsky::convo::get_convo::Error,
2573 > {
2574 let response = self
2575 .xrpc
2576 .send_xrpc::<
2577 _,
2578 (),
2579 _,
2580 _,
2581 >(
2582 &atrium_xrpc::XrpcRequest {
2583 method: http::Method::GET,
2584 nsid: crate::chat::bsky::convo::get_convo::NSID.into(),
2585 parameters: Some(params),
2586 input: None,
2587 encoding: None,
2588 },
2589 )
2590 .await?;
2591 match response {
2592 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2593 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2594 }
2595 }
2596 pub async fn get_convo_availability(
2598 &self,
2599 params: crate::chat::bsky::convo::get_convo_availability::Parameters,
2600 ) -> atrium_xrpc::Result<
2601 crate::chat::bsky::convo::get_convo_availability::Output,
2602 crate::chat::bsky::convo::get_convo_availability::Error,
2603 > {
2604 let response = self
2605 .xrpc
2606 .send_xrpc::<
2607 _,
2608 (),
2609 _,
2610 _,
2611 >(
2612 &atrium_xrpc::XrpcRequest {
2613 method: http::Method::GET,
2614 nsid: crate::chat::bsky::convo::get_convo_availability::NSID.into(),
2615 parameters: Some(params),
2616 input: None,
2617 encoding: None,
2618 },
2619 )
2620 .await?;
2621 match response {
2622 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2623 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2624 }
2625 }
2626 pub async fn get_convo_for_members(
2627 &self,
2628 params: crate::chat::bsky::convo::get_convo_for_members::Parameters,
2629 ) -> atrium_xrpc::Result<
2630 crate::chat::bsky::convo::get_convo_for_members::Output,
2631 crate::chat::bsky::convo::get_convo_for_members::Error,
2632 > {
2633 let response = self
2634 .xrpc
2635 .send_xrpc::<
2636 _,
2637 (),
2638 _,
2639 _,
2640 >(
2641 &atrium_xrpc::XrpcRequest {
2642 method: http::Method::GET,
2643 nsid: crate::chat::bsky::convo::get_convo_for_members::NSID.into(),
2644 parameters: Some(params),
2645 input: None,
2646 encoding: None,
2647 },
2648 )
2649 .await?;
2650 match response {
2651 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2652 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2653 }
2654 }
2655 pub async fn get_log(
2656 &self,
2657 params: crate::chat::bsky::convo::get_log::Parameters,
2658 ) -> atrium_xrpc::Result<
2659 crate::chat::bsky::convo::get_log::Output,
2660 crate::chat::bsky::convo::get_log::Error,
2661 > {
2662 let response = self
2663 .xrpc
2664 .send_xrpc::<
2665 _,
2666 (),
2667 _,
2668 _,
2669 >(
2670 &atrium_xrpc::XrpcRequest {
2671 method: http::Method::GET,
2672 nsid: crate::chat::bsky::convo::get_log::NSID.into(),
2673 parameters: Some(params),
2674 input: None,
2675 encoding: None,
2676 },
2677 )
2678 .await?;
2679 match response {
2680 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2681 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2682 }
2683 }
2684 pub async fn get_messages(
2685 &self,
2686 params: crate::chat::bsky::convo::get_messages::Parameters,
2687 ) -> atrium_xrpc::Result<
2688 crate::chat::bsky::convo::get_messages::Output,
2689 crate::chat::bsky::convo::get_messages::Error,
2690 > {
2691 let response = self
2692 .xrpc
2693 .send_xrpc::<
2694 _,
2695 (),
2696 _,
2697 _,
2698 >(
2699 &atrium_xrpc::XrpcRequest {
2700 method: http::Method::GET,
2701 nsid: crate::chat::bsky::convo::get_messages::NSID.into(),
2702 parameters: Some(params),
2703 input: None,
2704 encoding: None,
2705 },
2706 )
2707 .await?;
2708 match response {
2709 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2710 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2711 }
2712 }
2713 pub async fn leave_convo(
2714 &self,
2715 input: crate::chat::bsky::convo::leave_convo::Input,
2716 ) -> atrium_xrpc::Result<
2717 crate::chat::bsky::convo::leave_convo::Output,
2718 crate::chat::bsky::convo::leave_convo::Error,
2719 > {
2720 let response = self
2721 .xrpc
2722 .send_xrpc::<
2723 (),
2724 _,
2725 _,
2726 _,
2727 >(
2728 &atrium_xrpc::XrpcRequest {
2729 method: http::Method::POST,
2730 nsid: crate::chat::bsky::convo::leave_convo::NSID.into(),
2731 parameters: None,
2732 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2733 encoding: Some(String::from("application/json")),
2734 },
2735 )
2736 .await?;
2737 match response {
2738 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2739 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2740 }
2741 }
2742 pub async fn list_convos(
2743 &self,
2744 params: crate::chat::bsky::convo::list_convos::Parameters,
2745 ) -> atrium_xrpc::Result<
2746 crate::chat::bsky::convo::list_convos::Output,
2747 crate::chat::bsky::convo::list_convos::Error,
2748 > {
2749 let response = self
2750 .xrpc
2751 .send_xrpc::<
2752 _,
2753 (),
2754 _,
2755 _,
2756 >(
2757 &atrium_xrpc::XrpcRequest {
2758 method: http::Method::GET,
2759 nsid: crate::chat::bsky::convo::list_convos::NSID.into(),
2760 parameters: Some(params),
2761 input: None,
2762 encoding: None,
2763 },
2764 )
2765 .await?;
2766 match response {
2767 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2768 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2769 }
2770 }
2771 pub async fn mute_convo(
2772 &self,
2773 input: crate::chat::bsky::convo::mute_convo::Input,
2774 ) -> atrium_xrpc::Result<
2775 crate::chat::bsky::convo::mute_convo::Output,
2776 crate::chat::bsky::convo::mute_convo::Error,
2777 > {
2778 let response = self
2779 .xrpc
2780 .send_xrpc::<
2781 (),
2782 _,
2783 _,
2784 _,
2785 >(
2786 &atrium_xrpc::XrpcRequest {
2787 method: http::Method::POST,
2788 nsid: crate::chat::bsky::convo::mute_convo::NSID.into(),
2789 parameters: None,
2790 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2791 encoding: Some(String::from("application/json")),
2792 },
2793 )
2794 .await?;
2795 match response {
2796 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2797 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2798 }
2799 }
2800 pub async fn remove_reaction(
2802 &self,
2803 input: crate::chat::bsky::convo::remove_reaction::Input,
2804 ) -> atrium_xrpc::Result<
2805 crate::chat::bsky::convo::remove_reaction::Output,
2806 crate::chat::bsky::convo::remove_reaction::Error,
2807 > {
2808 let response = self
2809 .xrpc
2810 .send_xrpc::<
2811 (),
2812 _,
2813 _,
2814 _,
2815 >(
2816 &atrium_xrpc::XrpcRequest {
2817 method: http::Method::POST,
2818 nsid: crate::chat::bsky::convo::remove_reaction::NSID.into(),
2819 parameters: None,
2820 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2821 encoding: Some(String::from("application/json")),
2822 },
2823 )
2824 .await?;
2825 match response {
2826 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2827 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2828 }
2829 }
2830 pub async fn send_message(
2831 &self,
2832 input: crate::chat::bsky::convo::send_message::Input,
2833 ) -> atrium_xrpc::Result<
2834 crate::chat::bsky::convo::send_message::Output,
2835 crate::chat::bsky::convo::send_message::Error,
2836 > {
2837 let response = self
2838 .xrpc
2839 .send_xrpc::<
2840 (),
2841 _,
2842 _,
2843 _,
2844 >(
2845 &atrium_xrpc::XrpcRequest {
2846 method: http::Method::POST,
2847 nsid: crate::chat::bsky::convo::send_message::NSID.into(),
2848 parameters: None,
2849 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2850 encoding: Some(String::from("application/json")),
2851 },
2852 )
2853 .await?;
2854 match response {
2855 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2856 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2857 }
2858 }
2859 pub async fn send_message_batch(
2860 &self,
2861 input: crate::chat::bsky::convo::send_message_batch::Input,
2862 ) -> atrium_xrpc::Result<
2863 crate::chat::bsky::convo::send_message_batch::Output,
2864 crate::chat::bsky::convo::send_message_batch::Error,
2865 > {
2866 let response = self
2867 .xrpc
2868 .send_xrpc::<
2869 (),
2870 _,
2871 _,
2872 _,
2873 >(
2874 &atrium_xrpc::XrpcRequest {
2875 method: http::Method::POST,
2876 nsid: crate::chat::bsky::convo::send_message_batch::NSID.into(),
2877 parameters: None,
2878 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2879 encoding: Some(String::from("application/json")),
2880 },
2881 )
2882 .await?;
2883 match response {
2884 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2885 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2886 }
2887 }
2888 pub async fn unmute_convo(
2889 &self,
2890 input: crate::chat::bsky::convo::unmute_convo::Input,
2891 ) -> atrium_xrpc::Result<
2892 crate::chat::bsky::convo::unmute_convo::Output,
2893 crate::chat::bsky::convo::unmute_convo::Error,
2894 > {
2895 let response = self
2896 .xrpc
2897 .send_xrpc::<
2898 (),
2899 _,
2900 _,
2901 _,
2902 >(
2903 &atrium_xrpc::XrpcRequest {
2904 method: http::Method::POST,
2905 nsid: crate::chat::bsky::convo::unmute_convo::NSID.into(),
2906 parameters: None,
2907 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2908 encoding: Some(String::from("application/json")),
2909 },
2910 )
2911 .await?;
2912 match response {
2913 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2914 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2915 }
2916 }
2917 pub async fn update_all_read(
2918 &self,
2919 input: crate::chat::bsky::convo::update_all_read::Input,
2920 ) -> atrium_xrpc::Result<
2921 crate::chat::bsky::convo::update_all_read::Output,
2922 crate::chat::bsky::convo::update_all_read::Error,
2923 > {
2924 let response = self
2925 .xrpc
2926 .send_xrpc::<
2927 (),
2928 _,
2929 _,
2930 _,
2931 >(
2932 &atrium_xrpc::XrpcRequest {
2933 method: http::Method::POST,
2934 nsid: crate::chat::bsky::convo::update_all_read::NSID.into(),
2935 parameters: None,
2936 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2937 encoding: Some(String::from("application/json")),
2938 },
2939 )
2940 .await?;
2941 match response {
2942 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2943 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2944 }
2945 }
2946 pub async fn update_read(
2947 &self,
2948 input: crate::chat::bsky::convo::update_read::Input,
2949 ) -> atrium_xrpc::Result<
2950 crate::chat::bsky::convo::update_read::Output,
2951 crate::chat::bsky::convo::update_read::Error,
2952 > {
2953 let response = self
2954 .xrpc
2955 .send_xrpc::<
2956 (),
2957 _,
2958 _,
2959 _,
2960 >(
2961 &atrium_xrpc::XrpcRequest {
2962 method: http::Method::POST,
2963 nsid: crate::chat::bsky::convo::update_read::NSID.into(),
2964 parameters: None,
2965 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
2966 encoding: Some(String::from("application/json")),
2967 },
2968 )
2969 .await?;
2970 match response {
2971 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
2972 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
2973 }
2974 }
2975}
2976#[cfg(feature = "namespace-chatbsky")]
2977impl<T> chat::bsky::moderation::Service<T>
2978where
2979 T: atrium_xrpc::XrpcClient + Send + Sync,
2980{
2981 #[allow(unused_variables)]
2982 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
2983 Self {
2984 xrpc,
2985 _phantom: core::marker::PhantomData,
2986 }
2987 }
2988 pub async fn get_actor_metadata(
2989 &self,
2990 params: crate::chat::bsky::moderation::get_actor_metadata::Parameters,
2991 ) -> atrium_xrpc::Result<
2992 crate::chat::bsky::moderation::get_actor_metadata::Output,
2993 crate::chat::bsky::moderation::get_actor_metadata::Error,
2994 > {
2995 let response = self
2996 .xrpc
2997 .send_xrpc::<
2998 _,
2999 (),
3000 _,
3001 _,
3002 >(
3003 &atrium_xrpc::XrpcRequest {
3004 method: http::Method::GET,
3005 nsid: crate::chat::bsky::moderation::get_actor_metadata::NSID.into(),
3006 parameters: Some(params),
3007 input: None,
3008 encoding: None,
3009 },
3010 )
3011 .await?;
3012 match response {
3013 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3014 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3015 }
3016 }
3017 pub async fn get_message_context(
3018 &self,
3019 params: crate::chat::bsky::moderation::get_message_context::Parameters,
3020 ) -> atrium_xrpc::Result<
3021 crate::chat::bsky::moderation::get_message_context::Output,
3022 crate::chat::bsky::moderation::get_message_context::Error,
3023 > {
3024 let response = self
3025 .xrpc
3026 .send_xrpc::<
3027 _,
3028 (),
3029 _,
3030 _,
3031 >(
3032 &atrium_xrpc::XrpcRequest {
3033 method: http::Method::GET,
3034 nsid: crate::chat::bsky::moderation::get_message_context::NSID
3035 .into(),
3036 parameters: Some(params),
3037 input: None,
3038 encoding: None,
3039 },
3040 )
3041 .await?;
3042 match response {
3043 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3044 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3045 }
3046 }
3047 pub async fn update_actor_access(
3048 &self,
3049 input: crate::chat::bsky::moderation::update_actor_access::Input,
3050 ) -> atrium_xrpc::Result<
3051 (),
3052 crate::chat::bsky::moderation::update_actor_access::Error,
3053 > {
3054 let response = self
3055 .xrpc
3056 .send_xrpc::<
3057 (),
3058 _,
3059 (),
3060 _,
3061 >(
3062 &atrium_xrpc::XrpcRequest {
3063 method: http::Method::POST,
3064 nsid: crate::chat::bsky::moderation::update_actor_access::NSID
3065 .into(),
3066 parameters: None,
3067 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3068 encoding: Some(String::from("application/json")),
3069 },
3070 )
3071 .await?;
3072 match response {
3073 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3074 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3075 }
3076 }
3077}
3078impl<T> com::Service<T>
3079where
3080 T: atrium_xrpc::XrpcClient + Send + Sync,
3081{
3082 #[allow(unused_variables)]
3083 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3084 Self {
3085 atproto: com::atproto::Service::new(std::sync::Arc::clone(&xrpc)),
3086 _phantom: core::marker::PhantomData,
3087 }
3088 }
3089}
3090impl<T> com::atproto::Service<T>
3091where
3092 T: atrium_xrpc::XrpcClient + Send + Sync,
3093{
3094 #[allow(unused_variables)]
3095 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3096 Self {
3097 admin: com::atproto::admin::Service::new(std::sync::Arc::clone(&xrpc)),
3098 identity: com::atproto::identity::Service::new(std::sync::Arc::clone(&xrpc)),
3099 label: com::atproto::label::Service::new(std::sync::Arc::clone(&xrpc)),
3100 moderation: com::atproto::moderation::Service::new(
3101 std::sync::Arc::clone(&xrpc),
3102 ),
3103 repo: com::atproto::repo::Service::new(std::sync::Arc::clone(&xrpc)),
3104 server: com::atproto::server::Service::new(std::sync::Arc::clone(&xrpc)),
3105 sync: com::atproto::sync::Service::new(std::sync::Arc::clone(&xrpc)),
3106 temp: com::atproto::temp::Service::new(std::sync::Arc::clone(&xrpc)),
3107 _phantom: core::marker::PhantomData,
3108 }
3109 }
3110}
3111impl<T> com::atproto::admin::Service<T>
3112where
3113 T: atrium_xrpc::XrpcClient + Send + Sync,
3114{
3115 #[allow(unused_variables)]
3116 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3117 Self {
3118 xrpc,
3119 _phantom: core::marker::PhantomData,
3120 }
3121 }
3122 pub async fn delete_account(
3124 &self,
3125 input: crate::com::atproto::admin::delete_account::Input,
3126 ) -> atrium_xrpc::Result<(), crate::com::atproto::admin::delete_account::Error> {
3127 let response = self
3128 .xrpc
3129 .send_xrpc::<
3130 (),
3131 _,
3132 (),
3133 _,
3134 >(
3135 &atrium_xrpc::XrpcRequest {
3136 method: http::Method::POST,
3137 nsid: crate::com::atproto::admin::delete_account::NSID.into(),
3138 parameters: None,
3139 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3140 encoding: Some(String::from("application/json")),
3141 },
3142 )
3143 .await?;
3144 match response {
3145 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3146 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3147 }
3148 }
3149 pub async fn disable_account_invites(
3151 &self,
3152 input: crate::com::atproto::admin::disable_account_invites::Input,
3153 ) -> atrium_xrpc::Result<
3154 (),
3155 crate::com::atproto::admin::disable_account_invites::Error,
3156 > {
3157 let response = self
3158 .xrpc
3159 .send_xrpc::<
3160 (),
3161 _,
3162 (),
3163 _,
3164 >(
3165 &atrium_xrpc::XrpcRequest {
3166 method: http::Method::POST,
3167 nsid: crate::com::atproto::admin::disable_account_invites::NSID
3168 .into(),
3169 parameters: None,
3170 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3171 encoding: Some(String::from("application/json")),
3172 },
3173 )
3174 .await?;
3175 match response {
3176 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3177 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3178 }
3179 }
3180 pub async fn disable_invite_codes(
3182 &self,
3183 input: crate::com::atproto::admin::disable_invite_codes::Input,
3184 ) -> atrium_xrpc::Result<
3185 (),
3186 crate::com::atproto::admin::disable_invite_codes::Error,
3187 > {
3188 let response = self
3189 .xrpc
3190 .send_xrpc::<
3191 (),
3192 _,
3193 (),
3194 _,
3195 >(
3196 &atrium_xrpc::XrpcRequest {
3197 method: http::Method::POST,
3198 nsid: crate::com::atproto::admin::disable_invite_codes::NSID.into(),
3199 parameters: None,
3200 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3201 encoding: Some(String::from("application/json")),
3202 },
3203 )
3204 .await?;
3205 match response {
3206 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3207 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3208 }
3209 }
3210 pub async fn enable_account_invites(
3212 &self,
3213 input: crate::com::atproto::admin::enable_account_invites::Input,
3214 ) -> atrium_xrpc::Result<
3215 (),
3216 crate::com::atproto::admin::enable_account_invites::Error,
3217 > {
3218 let response = self
3219 .xrpc
3220 .send_xrpc::<
3221 (),
3222 _,
3223 (),
3224 _,
3225 >(
3226 &atrium_xrpc::XrpcRequest {
3227 method: http::Method::POST,
3228 nsid: crate::com::atproto::admin::enable_account_invites::NSID
3229 .into(),
3230 parameters: None,
3231 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3232 encoding: Some(String::from("application/json")),
3233 },
3234 )
3235 .await?;
3236 match response {
3237 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3238 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3239 }
3240 }
3241 pub async fn get_account_info(
3243 &self,
3244 params: crate::com::atproto::admin::get_account_info::Parameters,
3245 ) -> atrium_xrpc::Result<
3246 crate::com::atproto::admin::get_account_info::Output,
3247 crate::com::atproto::admin::get_account_info::Error,
3248 > {
3249 let response = self
3250 .xrpc
3251 .send_xrpc::<
3252 _,
3253 (),
3254 _,
3255 _,
3256 >(
3257 &atrium_xrpc::XrpcRequest {
3258 method: http::Method::GET,
3259 nsid: crate::com::atproto::admin::get_account_info::NSID.into(),
3260 parameters: Some(params),
3261 input: None,
3262 encoding: None,
3263 },
3264 )
3265 .await?;
3266 match response {
3267 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3268 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3269 }
3270 }
3271 pub async fn get_account_infos(
3273 &self,
3274 params: crate::com::atproto::admin::get_account_infos::Parameters,
3275 ) -> atrium_xrpc::Result<
3276 crate::com::atproto::admin::get_account_infos::Output,
3277 crate::com::atproto::admin::get_account_infos::Error,
3278 > {
3279 let response = self
3280 .xrpc
3281 .send_xrpc::<
3282 _,
3283 (),
3284 _,
3285 _,
3286 >(
3287 &atrium_xrpc::XrpcRequest {
3288 method: http::Method::GET,
3289 nsid: crate::com::atproto::admin::get_account_infos::NSID.into(),
3290 parameters: Some(params),
3291 input: None,
3292 encoding: None,
3293 },
3294 )
3295 .await?;
3296 match response {
3297 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3298 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3299 }
3300 }
3301 pub async fn get_invite_codes(
3303 &self,
3304 params: crate::com::atproto::admin::get_invite_codes::Parameters,
3305 ) -> atrium_xrpc::Result<
3306 crate::com::atproto::admin::get_invite_codes::Output,
3307 crate::com::atproto::admin::get_invite_codes::Error,
3308 > {
3309 let response = self
3310 .xrpc
3311 .send_xrpc::<
3312 _,
3313 (),
3314 _,
3315 _,
3316 >(
3317 &atrium_xrpc::XrpcRequest {
3318 method: http::Method::GET,
3319 nsid: crate::com::atproto::admin::get_invite_codes::NSID.into(),
3320 parameters: Some(params),
3321 input: None,
3322 encoding: None,
3323 },
3324 )
3325 .await?;
3326 match response {
3327 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3328 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3329 }
3330 }
3331 pub async fn get_subject_status(
3333 &self,
3334 params: crate::com::atproto::admin::get_subject_status::Parameters,
3335 ) -> atrium_xrpc::Result<
3336 crate::com::atproto::admin::get_subject_status::Output,
3337 crate::com::atproto::admin::get_subject_status::Error,
3338 > {
3339 let response = self
3340 .xrpc
3341 .send_xrpc::<
3342 _,
3343 (),
3344 _,
3345 _,
3346 >(
3347 &atrium_xrpc::XrpcRequest {
3348 method: http::Method::GET,
3349 nsid: crate::com::atproto::admin::get_subject_status::NSID.into(),
3350 parameters: Some(params),
3351 input: None,
3352 encoding: None,
3353 },
3354 )
3355 .await?;
3356 match response {
3357 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3358 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3359 }
3360 }
3361 pub async fn search_accounts(
3363 &self,
3364 params: crate::com::atproto::admin::search_accounts::Parameters,
3365 ) -> atrium_xrpc::Result<
3366 crate::com::atproto::admin::search_accounts::Output,
3367 crate::com::atproto::admin::search_accounts::Error,
3368 > {
3369 let response = self
3370 .xrpc
3371 .send_xrpc::<
3372 _,
3373 (),
3374 _,
3375 _,
3376 >(
3377 &atrium_xrpc::XrpcRequest {
3378 method: http::Method::GET,
3379 nsid: crate::com::atproto::admin::search_accounts::NSID.into(),
3380 parameters: Some(params),
3381 input: None,
3382 encoding: None,
3383 },
3384 )
3385 .await?;
3386 match response {
3387 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3388 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3389 }
3390 }
3391 pub async fn send_email(
3393 &self,
3394 input: crate::com::atproto::admin::send_email::Input,
3395 ) -> atrium_xrpc::Result<
3396 crate::com::atproto::admin::send_email::Output,
3397 crate::com::atproto::admin::send_email::Error,
3398 > {
3399 let response = self
3400 .xrpc
3401 .send_xrpc::<
3402 (),
3403 _,
3404 _,
3405 _,
3406 >(
3407 &atrium_xrpc::XrpcRequest {
3408 method: http::Method::POST,
3409 nsid: crate::com::atproto::admin::send_email::NSID.into(),
3410 parameters: None,
3411 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3412 encoding: Some(String::from("application/json")),
3413 },
3414 )
3415 .await?;
3416 match response {
3417 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3418 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3419 }
3420 }
3421 pub async fn update_account_email(
3423 &self,
3424 input: crate::com::atproto::admin::update_account_email::Input,
3425 ) -> atrium_xrpc::Result<
3426 (),
3427 crate::com::atproto::admin::update_account_email::Error,
3428 > {
3429 let response = self
3430 .xrpc
3431 .send_xrpc::<
3432 (),
3433 _,
3434 (),
3435 _,
3436 >(
3437 &atrium_xrpc::XrpcRequest {
3438 method: http::Method::POST,
3439 nsid: crate::com::atproto::admin::update_account_email::NSID.into(),
3440 parameters: None,
3441 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3442 encoding: Some(String::from("application/json")),
3443 },
3444 )
3445 .await?;
3446 match response {
3447 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3448 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3449 }
3450 }
3451 pub async fn update_account_handle(
3453 &self,
3454 input: crate::com::atproto::admin::update_account_handle::Input,
3455 ) -> atrium_xrpc::Result<
3456 (),
3457 crate::com::atproto::admin::update_account_handle::Error,
3458 > {
3459 let response = self
3460 .xrpc
3461 .send_xrpc::<
3462 (),
3463 _,
3464 (),
3465 _,
3466 >(
3467 &atrium_xrpc::XrpcRequest {
3468 method: http::Method::POST,
3469 nsid: crate::com::atproto::admin::update_account_handle::NSID.into(),
3470 parameters: None,
3471 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3472 encoding: Some(String::from("application/json")),
3473 },
3474 )
3475 .await?;
3476 match response {
3477 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3478 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3479 }
3480 }
3481 pub async fn update_account_password(
3483 &self,
3484 input: crate::com::atproto::admin::update_account_password::Input,
3485 ) -> atrium_xrpc::Result<
3486 (),
3487 crate::com::atproto::admin::update_account_password::Error,
3488 > {
3489 let response = self
3490 .xrpc
3491 .send_xrpc::<
3492 (),
3493 _,
3494 (),
3495 _,
3496 >(
3497 &atrium_xrpc::XrpcRequest {
3498 method: http::Method::POST,
3499 nsid: crate::com::atproto::admin::update_account_password::NSID
3500 .into(),
3501 parameters: None,
3502 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3503 encoding: Some(String::from("application/json")),
3504 },
3505 )
3506 .await?;
3507 match response {
3508 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3509 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3510 }
3511 }
3512 pub async fn update_subject_status(
3514 &self,
3515 input: crate::com::atproto::admin::update_subject_status::Input,
3516 ) -> atrium_xrpc::Result<
3517 crate::com::atproto::admin::update_subject_status::Output,
3518 crate::com::atproto::admin::update_subject_status::Error,
3519 > {
3520 let response = self
3521 .xrpc
3522 .send_xrpc::<
3523 (),
3524 _,
3525 _,
3526 _,
3527 >(
3528 &atrium_xrpc::XrpcRequest {
3529 method: http::Method::POST,
3530 nsid: crate::com::atproto::admin::update_subject_status::NSID.into(),
3531 parameters: None,
3532 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3533 encoding: Some(String::from("application/json")),
3534 },
3535 )
3536 .await?;
3537 match response {
3538 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3539 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3540 }
3541 }
3542}
3543impl<T> com::atproto::identity::Service<T>
3544where
3545 T: atrium_xrpc::XrpcClient + Send + Sync,
3546{
3547 #[allow(unused_variables)]
3548 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3549 Self {
3550 xrpc,
3551 _phantom: core::marker::PhantomData,
3552 }
3553 }
3554 pub async fn get_recommended_did_credentials(
3556 &self,
3557 ) -> atrium_xrpc::Result<
3558 crate::com::atproto::identity::get_recommended_did_credentials::Output,
3559 crate::com::atproto::identity::get_recommended_did_credentials::Error,
3560 > {
3561 let response = self
3562 .xrpc
3563 .send_xrpc::<
3564 (),
3565 (),
3566 _,
3567 _,
3568 >(
3569 &atrium_xrpc::XrpcRequest {
3570 method: http::Method::GET,
3571 nsid: crate::com::atproto::identity::get_recommended_did_credentials::NSID
3572 .into(),
3573 parameters: None,
3574 input: None,
3575 encoding: None,
3576 },
3577 )
3578 .await?;
3579 match response {
3580 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3581 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3582 }
3583 }
3584 pub async fn refresh_identity(
3586 &self,
3587 input: crate::com::atproto::identity::refresh_identity::Input,
3588 ) -> atrium_xrpc::Result<
3589 crate::com::atproto::identity::refresh_identity::Output,
3590 crate::com::atproto::identity::refresh_identity::Error,
3591 > {
3592 let response = self
3593 .xrpc
3594 .send_xrpc::<
3595 (),
3596 _,
3597 _,
3598 _,
3599 >(
3600 &atrium_xrpc::XrpcRequest {
3601 method: http::Method::POST,
3602 nsid: crate::com::atproto::identity::refresh_identity::NSID.into(),
3603 parameters: None,
3604 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3605 encoding: Some(String::from("application/json")),
3606 },
3607 )
3608 .await?;
3609 match response {
3610 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3611 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3612 }
3613 }
3614 pub async fn request_plc_operation_signature(
3616 &self,
3617 ) -> atrium_xrpc::Result<
3618 (),
3619 crate::com::atproto::identity::request_plc_operation_signature::Error,
3620 > {
3621 let response = self
3622 .xrpc
3623 .send_xrpc::<
3624 (),
3625 (),
3626 (),
3627 _,
3628 >(
3629 &atrium_xrpc::XrpcRequest {
3630 method: http::Method::POST,
3631 nsid: crate::com::atproto::identity::request_plc_operation_signature::NSID
3632 .into(),
3633 parameters: None,
3634 input: None,
3635 encoding: None,
3636 },
3637 )
3638 .await?;
3639 match response {
3640 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3641 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3642 }
3643 }
3644 pub async fn resolve_did(
3646 &self,
3647 params: crate::com::atproto::identity::resolve_did::Parameters,
3648 ) -> atrium_xrpc::Result<
3649 crate::com::atproto::identity::resolve_did::Output,
3650 crate::com::atproto::identity::resolve_did::Error,
3651 > {
3652 let response = self
3653 .xrpc
3654 .send_xrpc::<
3655 _,
3656 (),
3657 _,
3658 _,
3659 >(
3660 &atrium_xrpc::XrpcRequest {
3661 method: http::Method::GET,
3662 nsid: crate::com::atproto::identity::resolve_did::NSID.into(),
3663 parameters: Some(params),
3664 input: None,
3665 encoding: None,
3666 },
3667 )
3668 .await?;
3669 match response {
3670 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3671 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3672 }
3673 }
3674 pub async fn resolve_handle(
3676 &self,
3677 params: crate::com::atproto::identity::resolve_handle::Parameters,
3678 ) -> atrium_xrpc::Result<
3679 crate::com::atproto::identity::resolve_handle::Output,
3680 crate::com::atproto::identity::resolve_handle::Error,
3681 > {
3682 let response = self
3683 .xrpc
3684 .send_xrpc::<
3685 _,
3686 (),
3687 _,
3688 _,
3689 >(
3690 &atrium_xrpc::XrpcRequest {
3691 method: http::Method::GET,
3692 nsid: crate::com::atproto::identity::resolve_handle::NSID.into(),
3693 parameters: Some(params),
3694 input: None,
3695 encoding: None,
3696 },
3697 )
3698 .await?;
3699 match response {
3700 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3701 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3702 }
3703 }
3704 pub async fn resolve_identity(
3706 &self,
3707 params: crate::com::atproto::identity::resolve_identity::Parameters,
3708 ) -> atrium_xrpc::Result<
3709 crate::com::atproto::identity::resolve_identity::Output,
3710 crate::com::atproto::identity::resolve_identity::Error,
3711 > {
3712 let response = self
3713 .xrpc
3714 .send_xrpc::<
3715 _,
3716 (),
3717 _,
3718 _,
3719 >(
3720 &atrium_xrpc::XrpcRequest {
3721 method: http::Method::GET,
3722 nsid: crate::com::atproto::identity::resolve_identity::NSID.into(),
3723 parameters: Some(params),
3724 input: None,
3725 encoding: None,
3726 },
3727 )
3728 .await?;
3729 match response {
3730 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3731 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3732 }
3733 }
3734 pub async fn sign_plc_operation(
3736 &self,
3737 input: crate::com::atproto::identity::sign_plc_operation::Input,
3738 ) -> atrium_xrpc::Result<
3739 crate::com::atproto::identity::sign_plc_operation::Output,
3740 crate::com::atproto::identity::sign_plc_operation::Error,
3741 > {
3742 let response = self
3743 .xrpc
3744 .send_xrpc::<
3745 (),
3746 _,
3747 _,
3748 _,
3749 >(
3750 &atrium_xrpc::XrpcRequest {
3751 method: http::Method::POST,
3752 nsid: crate::com::atproto::identity::sign_plc_operation::NSID.into(),
3753 parameters: None,
3754 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3755 encoding: Some(String::from("application/json")),
3756 },
3757 )
3758 .await?;
3759 match response {
3760 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3761 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3762 }
3763 }
3764 pub async fn submit_plc_operation(
3766 &self,
3767 input: crate::com::atproto::identity::submit_plc_operation::Input,
3768 ) -> atrium_xrpc::Result<
3769 (),
3770 crate::com::atproto::identity::submit_plc_operation::Error,
3771 > {
3772 let response = self
3773 .xrpc
3774 .send_xrpc::<
3775 (),
3776 _,
3777 (),
3778 _,
3779 >(
3780 &atrium_xrpc::XrpcRequest {
3781 method: http::Method::POST,
3782 nsid: crate::com::atproto::identity::submit_plc_operation::NSID
3783 .into(),
3784 parameters: None,
3785 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3786 encoding: Some(String::from("application/json")),
3787 },
3788 )
3789 .await?;
3790 match response {
3791 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3792 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3793 }
3794 }
3795 pub async fn update_handle(
3797 &self,
3798 input: crate::com::atproto::identity::update_handle::Input,
3799 ) -> atrium_xrpc::Result<(), crate::com::atproto::identity::update_handle::Error> {
3800 let response = self
3801 .xrpc
3802 .send_xrpc::<
3803 (),
3804 _,
3805 (),
3806 _,
3807 >(
3808 &atrium_xrpc::XrpcRequest {
3809 method: http::Method::POST,
3810 nsid: crate::com::atproto::identity::update_handle::NSID.into(),
3811 parameters: None,
3812 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3813 encoding: Some(String::from("application/json")),
3814 },
3815 )
3816 .await?;
3817 match response {
3818 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
3819 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3820 }
3821 }
3822}
3823impl<T> com::atproto::label::Service<T>
3824where
3825 T: atrium_xrpc::XrpcClient + Send + Sync,
3826{
3827 #[allow(unused_variables)]
3828 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3829 Self {
3830 xrpc,
3831 _phantom: core::marker::PhantomData,
3832 }
3833 }
3834 pub async fn query_labels(
3836 &self,
3837 params: crate::com::atproto::label::query_labels::Parameters,
3838 ) -> atrium_xrpc::Result<
3839 crate::com::atproto::label::query_labels::Output,
3840 crate::com::atproto::label::query_labels::Error,
3841 > {
3842 let response = self
3843 .xrpc
3844 .send_xrpc::<
3845 _,
3846 (),
3847 _,
3848 _,
3849 >(
3850 &atrium_xrpc::XrpcRequest {
3851 method: http::Method::GET,
3852 nsid: crate::com::atproto::label::query_labels::NSID.into(),
3853 parameters: Some(params),
3854 input: None,
3855 encoding: None,
3856 },
3857 )
3858 .await?;
3859 match response {
3860 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3861 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3862 }
3863 }
3864}
3865impl<T> com::atproto::moderation::Service<T>
3866where
3867 T: atrium_xrpc::XrpcClient + Send + Sync,
3868{
3869 #[allow(unused_variables)]
3870 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3871 Self {
3872 xrpc,
3873 _phantom: core::marker::PhantomData,
3874 }
3875 }
3876 pub async fn create_report(
3878 &self,
3879 input: crate::com::atproto::moderation::create_report::Input,
3880 ) -> atrium_xrpc::Result<
3881 crate::com::atproto::moderation::create_report::Output,
3882 crate::com::atproto::moderation::create_report::Error,
3883 > {
3884 let response = self
3885 .xrpc
3886 .send_xrpc::<
3887 (),
3888 _,
3889 _,
3890 _,
3891 >(
3892 &atrium_xrpc::XrpcRequest {
3893 method: http::Method::POST,
3894 nsid: crate::com::atproto::moderation::create_report::NSID.into(),
3895 parameters: None,
3896 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3897 encoding: Some(String::from("application/json")),
3898 },
3899 )
3900 .await?;
3901 match response {
3902 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3903 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3904 }
3905 }
3906}
3907impl<T> com::atproto::repo::Service<T>
3908where
3909 T: atrium_xrpc::XrpcClient + Send + Sync,
3910{
3911 #[allow(unused_variables)]
3912 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
3913 Self {
3914 xrpc,
3915 _phantom: core::marker::PhantomData,
3916 }
3917 }
3918 pub async fn apply_writes(
3920 &self,
3921 input: crate::com::atproto::repo::apply_writes::Input,
3922 ) -> atrium_xrpc::Result<
3923 crate::com::atproto::repo::apply_writes::Output,
3924 crate::com::atproto::repo::apply_writes::Error,
3925 > {
3926 let response = self
3927 .xrpc
3928 .send_xrpc::<
3929 (),
3930 _,
3931 _,
3932 _,
3933 >(
3934 &atrium_xrpc::XrpcRequest {
3935 method: http::Method::POST,
3936 nsid: crate::com::atproto::repo::apply_writes::NSID.into(),
3937 parameters: None,
3938 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3939 encoding: Some(String::from("application/json")),
3940 },
3941 )
3942 .await?;
3943 match response {
3944 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3945 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3946 }
3947 }
3948 pub async fn create_record(
3950 &self,
3951 input: crate::com::atproto::repo::create_record::Input,
3952 ) -> atrium_xrpc::Result<
3953 crate::com::atproto::repo::create_record::Output,
3954 crate::com::atproto::repo::create_record::Error,
3955 > {
3956 let response = self
3957 .xrpc
3958 .send_xrpc::<
3959 (),
3960 _,
3961 _,
3962 _,
3963 >(
3964 &atrium_xrpc::XrpcRequest {
3965 method: http::Method::POST,
3966 nsid: crate::com::atproto::repo::create_record::NSID.into(),
3967 parameters: None,
3968 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3969 encoding: Some(String::from("application/json")),
3970 },
3971 )
3972 .await?;
3973 match response {
3974 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
3975 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
3976 }
3977 }
3978 pub async fn delete_record(
3980 &self,
3981 input: crate::com::atproto::repo::delete_record::Input,
3982 ) -> atrium_xrpc::Result<
3983 crate::com::atproto::repo::delete_record::Output,
3984 crate::com::atproto::repo::delete_record::Error,
3985 > {
3986 let response = self
3987 .xrpc
3988 .send_xrpc::<
3989 (),
3990 _,
3991 _,
3992 _,
3993 >(
3994 &atrium_xrpc::XrpcRequest {
3995 method: http::Method::POST,
3996 nsid: crate::com::atproto::repo::delete_record::NSID.into(),
3997 parameters: None,
3998 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
3999 encoding: Some(String::from("application/json")),
4000 },
4001 )
4002 .await?;
4003 match response {
4004 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4005 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4006 }
4007 }
4008 pub async fn describe_repo(
4010 &self,
4011 params: crate::com::atproto::repo::describe_repo::Parameters,
4012 ) -> atrium_xrpc::Result<
4013 crate::com::atproto::repo::describe_repo::Output,
4014 crate::com::atproto::repo::describe_repo::Error,
4015 > {
4016 let response = self
4017 .xrpc
4018 .send_xrpc::<
4019 _,
4020 (),
4021 _,
4022 _,
4023 >(
4024 &atrium_xrpc::XrpcRequest {
4025 method: http::Method::GET,
4026 nsid: crate::com::atproto::repo::describe_repo::NSID.into(),
4027 parameters: Some(params),
4028 input: None,
4029 encoding: None,
4030 },
4031 )
4032 .await?;
4033 match response {
4034 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4035 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4036 }
4037 }
4038 pub async fn get_record(
4040 &self,
4041 params: crate::com::atproto::repo::get_record::Parameters,
4042 ) -> atrium_xrpc::Result<
4043 crate::com::atproto::repo::get_record::Output,
4044 crate::com::atproto::repo::get_record::Error,
4045 > {
4046 let response = self
4047 .xrpc
4048 .send_xrpc::<
4049 _,
4050 (),
4051 _,
4052 _,
4053 >(
4054 &atrium_xrpc::XrpcRequest {
4055 method: http::Method::GET,
4056 nsid: crate::com::atproto::repo::get_record::NSID.into(),
4057 parameters: Some(params),
4058 input: None,
4059 encoding: None,
4060 },
4061 )
4062 .await?;
4063 match response {
4064 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4065 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4066 }
4067 }
4068 pub async fn import_repo(
4070 &self,
4071 input: Vec<u8>,
4072 ) -> atrium_xrpc::Result<(), crate::com::atproto::repo::import_repo::Error> {
4073 let response = self
4074 .xrpc
4075 .send_xrpc::<
4076 (),
4077 Vec<u8>,
4078 (),
4079 _,
4080 >(
4081 &atrium_xrpc::XrpcRequest {
4082 method: http::Method::POST,
4083 nsid: crate::com::atproto::repo::import_repo::NSID.into(),
4084 parameters: None,
4085 input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
4086 encoding: Some(String::from("application/vnd.ipld.car")),
4087 },
4088 )
4089 .await?;
4090 match response {
4091 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4092 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4093 }
4094 }
4095 pub async fn list_missing_blobs(
4097 &self,
4098 params: crate::com::atproto::repo::list_missing_blobs::Parameters,
4099 ) -> atrium_xrpc::Result<
4100 crate::com::atproto::repo::list_missing_blobs::Output,
4101 crate::com::atproto::repo::list_missing_blobs::Error,
4102 > {
4103 let response = self
4104 .xrpc
4105 .send_xrpc::<
4106 _,
4107 (),
4108 _,
4109 _,
4110 >(
4111 &atrium_xrpc::XrpcRequest {
4112 method: http::Method::GET,
4113 nsid: crate::com::atproto::repo::list_missing_blobs::NSID.into(),
4114 parameters: Some(params),
4115 input: None,
4116 encoding: None,
4117 },
4118 )
4119 .await?;
4120 match response {
4121 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4122 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4123 }
4124 }
4125 pub async fn list_records(
4127 &self,
4128 params: crate::com::atproto::repo::list_records::Parameters,
4129 ) -> atrium_xrpc::Result<
4130 crate::com::atproto::repo::list_records::Output,
4131 crate::com::atproto::repo::list_records::Error,
4132 > {
4133 let response = self
4134 .xrpc
4135 .send_xrpc::<
4136 _,
4137 (),
4138 _,
4139 _,
4140 >(
4141 &atrium_xrpc::XrpcRequest {
4142 method: http::Method::GET,
4143 nsid: crate::com::atproto::repo::list_records::NSID.into(),
4144 parameters: Some(params),
4145 input: None,
4146 encoding: None,
4147 },
4148 )
4149 .await?;
4150 match response {
4151 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4152 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4153 }
4154 }
4155 pub async fn put_record(
4157 &self,
4158 input: crate::com::atproto::repo::put_record::Input,
4159 ) -> atrium_xrpc::Result<
4160 crate::com::atproto::repo::put_record::Output,
4161 crate::com::atproto::repo::put_record::Error,
4162 > {
4163 let response = self
4164 .xrpc
4165 .send_xrpc::<
4166 (),
4167 _,
4168 _,
4169 _,
4170 >(
4171 &atrium_xrpc::XrpcRequest {
4172 method: http::Method::POST,
4173 nsid: crate::com::atproto::repo::put_record::NSID.into(),
4174 parameters: None,
4175 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4176 encoding: Some(String::from("application/json")),
4177 },
4178 )
4179 .await?;
4180 match response {
4181 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4182 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4183 }
4184 }
4185 pub async fn upload_blob(
4187 &self,
4188 input: Vec<u8>,
4189 ) -> atrium_xrpc::Result<
4190 crate::com::atproto::repo::upload_blob::Output,
4191 crate::com::atproto::repo::upload_blob::Error,
4192 > {
4193 let response = self
4194 .xrpc
4195 .send_xrpc::<
4196 (),
4197 Vec<u8>,
4198 _,
4199 _,
4200 >(
4201 &atrium_xrpc::XrpcRequest {
4202 method: http::Method::POST,
4203 nsid: crate::com::atproto::repo::upload_blob::NSID.into(),
4204 parameters: None,
4205 input: Some(atrium_xrpc::InputDataOrBytes::Bytes(input)),
4206 encoding: Some(String::from("*/*")),
4207 },
4208 )
4209 .await?;
4210 match response {
4211 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4212 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4213 }
4214 }
4215}
4216impl<T> com::atproto::server::Service<T>
4217where
4218 T: atrium_xrpc::XrpcClient + Send + Sync,
4219{
4220 #[allow(unused_variables)]
4221 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
4222 Self {
4223 xrpc,
4224 _phantom: core::marker::PhantomData,
4225 }
4226 }
4227 pub async fn activate_account(
4229 &self,
4230 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::activate_account::Error> {
4231 let response = self
4232 .xrpc
4233 .send_xrpc::<
4234 (),
4235 (),
4236 (),
4237 _,
4238 >(
4239 &atrium_xrpc::XrpcRequest {
4240 method: http::Method::POST,
4241 nsid: crate::com::atproto::server::activate_account::NSID.into(),
4242 parameters: None,
4243 input: None,
4244 encoding: None,
4245 },
4246 )
4247 .await?;
4248 match response {
4249 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4250 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4251 }
4252 }
4253 pub async fn check_account_status(
4255 &self,
4256 ) -> atrium_xrpc::Result<
4257 crate::com::atproto::server::check_account_status::Output,
4258 crate::com::atproto::server::check_account_status::Error,
4259 > {
4260 let response = self
4261 .xrpc
4262 .send_xrpc::<
4263 (),
4264 (),
4265 _,
4266 _,
4267 >(
4268 &atrium_xrpc::XrpcRequest {
4269 method: http::Method::GET,
4270 nsid: crate::com::atproto::server::check_account_status::NSID.into(),
4271 parameters: None,
4272 input: None,
4273 encoding: None,
4274 },
4275 )
4276 .await?;
4277 match response {
4278 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4279 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4280 }
4281 }
4282 pub async fn confirm_email(
4284 &self,
4285 input: crate::com::atproto::server::confirm_email::Input,
4286 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::confirm_email::Error> {
4287 let response = self
4288 .xrpc
4289 .send_xrpc::<
4290 (),
4291 _,
4292 (),
4293 _,
4294 >(
4295 &atrium_xrpc::XrpcRequest {
4296 method: http::Method::POST,
4297 nsid: crate::com::atproto::server::confirm_email::NSID.into(),
4298 parameters: None,
4299 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4300 encoding: Some(String::from("application/json")),
4301 },
4302 )
4303 .await?;
4304 match response {
4305 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4306 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4307 }
4308 }
4309 pub async fn create_account(
4311 &self,
4312 input: crate::com::atproto::server::create_account::Input,
4313 ) -> atrium_xrpc::Result<
4314 crate::com::atproto::server::create_account::Output,
4315 crate::com::atproto::server::create_account::Error,
4316 > {
4317 let response = self
4318 .xrpc
4319 .send_xrpc::<
4320 (),
4321 _,
4322 _,
4323 _,
4324 >(
4325 &atrium_xrpc::XrpcRequest {
4326 method: http::Method::POST,
4327 nsid: crate::com::atproto::server::create_account::NSID.into(),
4328 parameters: None,
4329 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4330 encoding: Some(String::from("application/json")),
4331 },
4332 )
4333 .await?;
4334 match response {
4335 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4336 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4337 }
4338 }
4339 pub async fn create_app_password(
4341 &self,
4342 input: crate::com::atproto::server::create_app_password::Input,
4343 ) -> atrium_xrpc::Result<
4344 crate::com::atproto::server::create_app_password::Output,
4345 crate::com::atproto::server::create_app_password::Error,
4346 > {
4347 let response = self
4348 .xrpc
4349 .send_xrpc::<
4350 (),
4351 _,
4352 _,
4353 _,
4354 >(
4355 &atrium_xrpc::XrpcRequest {
4356 method: http::Method::POST,
4357 nsid: crate::com::atproto::server::create_app_password::NSID.into(),
4358 parameters: None,
4359 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4360 encoding: Some(String::from("application/json")),
4361 },
4362 )
4363 .await?;
4364 match response {
4365 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4366 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4367 }
4368 }
4369 pub async fn create_invite_code(
4371 &self,
4372 input: crate::com::atproto::server::create_invite_code::Input,
4373 ) -> atrium_xrpc::Result<
4374 crate::com::atproto::server::create_invite_code::Output,
4375 crate::com::atproto::server::create_invite_code::Error,
4376 > {
4377 let response = self
4378 .xrpc
4379 .send_xrpc::<
4380 (),
4381 _,
4382 _,
4383 _,
4384 >(
4385 &atrium_xrpc::XrpcRequest {
4386 method: http::Method::POST,
4387 nsid: crate::com::atproto::server::create_invite_code::NSID.into(),
4388 parameters: None,
4389 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4390 encoding: Some(String::from("application/json")),
4391 },
4392 )
4393 .await?;
4394 match response {
4395 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4396 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4397 }
4398 }
4399 pub async fn create_invite_codes(
4401 &self,
4402 input: crate::com::atproto::server::create_invite_codes::Input,
4403 ) -> atrium_xrpc::Result<
4404 crate::com::atproto::server::create_invite_codes::Output,
4405 crate::com::atproto::server::create_invite_codes::Error,
4406 > {
4407 let response = self
4408 .xrpc
4409 .send_xrpc::<
4410 (),
4411 _,
4412 _,
4413 _,
4414 >(
4415 &atrium_xrpc::XrpcRequest {
4416 method: http::Method::POST,
4417 nsid: crate::com::atproto::server::create_invite_codes::NSID.into(),
4418 parameters: None,
4419 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4420 encoding: Some(String::from("application/json")),
4421 },
4422 )
4423 .await?;
4424 match response {
4425 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4426 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4427 }
4428 }
4429 pub async fn create_session(
4431 &self,
4432 input: crate::com::atproto::server::create_session::Input,
4433 ) -> atrium_xrpc::Result<
4434 crate::com::atproto::server::create_session::Output,
4435 crate::com::atproto::server::create_session::Error,
4436 > {
4437 let response = self
4438 .xrpc
4439 .send_xrpc::<
4440 (),
4441 _,
4442 _,
4443 _,
4444 >(
4445 &atrium_xrpc::XrpcRequest {
4446 method: http::Method::POST,
4447 nsid: crate::com::atproto::server::create_session::NSID.into(),
4448 parameters: None,
4449 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4450 encoding: Some(String::from("application/json")),
4451 },
4452 )
4453 .await?;
4454 match response {
4455 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4456 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4457 }
4458 }
4459 pub async fn deactivate_account(
4461 &self,
4462 input: crate::com::atproto::server::deactivate_account::Input,
4463 ) -> atrium_xrpc::Result<
4464 (),
4465 crate::com::atproto::server::deactivate_account::Error,
4466 > {
4467 let response = self
4468 .xrpc
4469 .send_xrpc::<
4470 (),
4471 _,
4472 (),
4473 _,
4474 >(
4475 &atrium_xrpc::XrpcRequest {
4476 method: http::Method::POST,
4477 nsid: crate::com::atproto::server::deactivate_account::NSID.into(),
4478 parameters: None,
4479 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4480 encoding: Some(String::from("application/json")),
4481 },
4482 )
4483 .await?;
4484 match response {
4485 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4486 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4487 }
4488 }
4489 pub async fn delete_account(
4491 &self,
4492 input: crate::com::atproto::server::delete_account::Input,
4493 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::delete_account::Error> {
4494 let response = self
4495 .xrpc
4496 .send_xrpc::<
4497 (),
4498 _,
4499 (),
4500 _,
4501 >(
4502 &atrium_xrpc::XrpcRequest {
4503 method: http::Method::POST,
4504 nsid: crate::com::atproto::server::delete_account::NSID.into(),
4505 parameters: None,
4506 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4507 encoding: Some(String::from("application/json")),
4508 },
4509 )
4510 .await?;
4511 match response {
4512 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4513 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4514 }
4515 }
4516 pub async fn delete_session(
4518 &self,
4519 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::delete_session::Error> {
4520 let response = self
4521 .xrpc
4522 .send_xrpc::<
4523 (),
4524 (),
4525 (),
4526 _,
4527 >(
4528 &atrium_xrpc::XrpcRequest {
4529 method: http::Method::POST,
4530 nsid: crate::com::atproto::server::delete_session::NSID.into(),
4531 parameters: None,
4532 input: None,
4533 encoding: None,
4534 },
4535 )
4536 .await?;
4537 match response {
4538 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4539 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4540 }
4541 }
4542 pub async fn describe_server(
4544 &self,
4545 ) -> atrium_xrpc::Result<
4546 crate::com::atproto::server::describe_server::Output,
4547 crate::com::atproto::server::describe_server::Error,
4548 > {
4549 let response = self
4550 .xrpc
4551 .send_xrpc::<
4552 (),
4553 (),
4554 _,
4555 _,
4556 >(
4557 &atrium_xrpc::XrpcRequest {
4558 method: http::Method::GET,
4559 nsid: crate::com::atproto::server::describe_server::NSID.into(),
4560 parameters: None,
4561 input: None,
4562 encoding: None,
4563 },
4564 )
4565 .await?;
4566 match response {
4567 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4568 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4569 }
4570 }
4571 pub async fn get_account_invite_codes(
4573 &self,
4574 params: crate::com::atproto::server::get_account_invite_codes::Parameters,
4575 ) -> atrium_xrpc::Result<
4576 crate::com::atproto::server::get_account_invite_codes::Output,
4577 crate::com::atproto::server::get_account_invite_codes::Error,
4578 > {
4579 let response = self
4580 .xrpc
4581 .send_xrpc::<
4582 _,
4583 (),
4584 _,
4585 _,
4586 >(
4587 &atrium_xrpc::XrpcRequest {
4588 method: http::Method::GET,
4589 nsid: crate::com::atproto::server::get_account_invite_codes::NSID
4590 .into(),
4591 parameters: Some(params),
4592 input: None,
4593 encoding: None,
4594 },
4595 )
4596 .await?;
4597 match response {
4598 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4599 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4600 }
4601 }
4602 pub async fn get_service_auth(
4604 &self,
4605 params: crate::com::atproto::server::get_service_auth::Parameters,
4606 ) -> atrium_xrpc::Result<
4607 crate::com::atproto::server::get_service_auth::Output,
4608 crate::com::atproto::server::get_service_auth::Error,
4609 > {
4610 let response = self
4611 .xrpc
4612 .send_xrpc::<
4613 _,
4614 (),
4615 _,
4616 _,
4617 >(
4618 &atrium_xrpc::XrpcRequest {
4619 method: http::Method::GET,
4620 nsid: crate::com::atproto::server::get_service_auth::NSID.into(),
4621 parameters: Some(params),
4622 input: None,
4623 encoding: None,
4624 },
4625 )
4626 .await?;
4627 match response {
4628 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4629 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4630 }
4631 }
4632 pub async fn get_session(
4634 &self,
4635 ) -> atrium_xrpc::Result<
4636 crate::com::atproto::server::get_session::Output,
4637 crate::com::atproto::server::get_session::Error,
4638 > {
4639 let response = self
4640 .xrpc
4641 .send_xrpc::<
4642 (),
4643 (),
4644 _,
4645 _,
4646 >(
4647 &atrium_xrpc::XrpcRequest {
4648 method: http::Method::GET,
4649 nsid: crate::com::atproto::server::get_session::NSID.into(),
4650 parameters: None,
4651 input: None,
4652 encoding: None,
4653 },
4654 )
4655 .await?;
4656 match response {
4657 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4658 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4659 }
4660 }
4661 pub async fn list_app_passwords(
4663 &self,
4664 ) -> atrium_xrpc::Result<
4665 crate::com::atproto::server::list_app_passwords::Output,
4666 crate::com::atproto::server::list_app_passwords::Error,
4667 > {
4668 let response = self
4669 .xrpc
4670 .send_xrpc::<
4671 (),
4672 (),
4673 _,
4674 _,
4675 >(
4676 &atrium_xrpc::XrpcRequest {
4677 method: http::Method::GET,
4678 nsid: crate::com::atproto::server::list_app_passwords::NSID.into(),
4679 parameters: None,
4680 input: None,
4681 encoding: None,
4682 },
4683 )
4684 .await?;
4685 match response {
4686 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4687 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4688 }
4689 }
4690 pub async fn refresh_session(
4692 &self,
4693 ) -> atrium_xrpc::Result<
4694 crate::com::atproto::server::refresh_session::Output,
4695 crate::com::atproto::server::refresh_session::Error,
4696 > {
4697 let response = self
4698 .xrpc
4699 .send_xrpc::<
4700 (),
4701 (),
4702 _,
4703 _,
4704 >(
4705 &atrium_xrpc::XrpcRequest {
4706 method: http::Method::POST,
4707 nsid: crate::com::atproto::server::refresh_session::NSID.into(),
4708 parameters: None,
4709 input: None,
4710 encoding: None,
4711 },
4712 )
4713 .await?;
4714 match response {
4715 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4716 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4717 }
4718 }
4719 pub async fn request_account_delete(
4721 &self,
4722 ) -> atrium_xrpc::Result<
4723 (),
4724 crate::com::atproto::server::request_account_delete::Error,
4725 > {
4726 let response = self
4727 .xrpc
4728 .send_xrpc::<
4729 (),
4730 (),
4731 (),
4732 _,
4733 >(
4734 &atrium_xrpc::XrpcRequest {
4735 method: http::Method::POST,
4736 nsid: crate::com::atproto::server::request_account_delete::NSID
4737 .into(),
4738 parameters: None,
4739 input: None,
4740 encoding: None,
4741 },
4742 )
4743 .await?;
4744 match response {
4745 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4746 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4747 }
4748 }
4749 pub async fn request_email_confirmation(
4751 &self,
4752 ) -> atrium_xrpc::Result<
4753 (),
4754 crate::com::atproto::server::request_email_confirmation::Error,
4755 > {
4756 let response = self
4757 .xrpc
4758 .send_xrpc::<
4759 (),
4760 (),
4761 (),
4762 _,
4763 >(
4764 &atrium_xrpc::XrpcRequest {
4765 method: http::Method::POST,
4766 nsid: crate::com::atproto::server::request_email_confirmation::NSID
4767 .into(),
4768 parameters: None,
4769 input: None,
4770 encoding: None,
4771 },
4772 )
4773 .await?;
4774 match response {
4775 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4776 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4777 }
4778 }
4779 pub async fn request_email_update(
4781 &self,
4782 ) -> atrium_xrpc::Result<
4783 crate::com::atproto::server::request_email_update::Output,
4784 crate::com::atproto::server::request_email_update::Error,
4785 > {
4786 let response = self
4787 .xrpc
4788 .send_xrpc::<
4789 (),
4790 (),
4791 _,
4792 _,
4793 >(
4794 &atrium_xrpc::XrpcRequest {
4795 method: http::Method::POST,
4796 nsid: crate::com::atproto::server::request_email_update::NSID.into(),
4797 parameters: None,
4798 input: None,
4799 encoding: None,
4800 },
4801 )
4802 .await?;
4803 match response {
4804 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4805 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4806 }
4807 }
4808 pub async fn request_password_reset(
4810 &self,
4811 input: crate::com::atproto::server::request_password_reset::Input,
4812 ) -> atrium_xrpc::Result<
4813 (),
4814 crate::com::atproto::server::request_password_reset::Error,
4815 > {
4816 let response = self
4817 .xrpc
4818 .send_xrpc::<
4819 (),
4820 _,
4821 (),
4822 _,
4823 >(
4824 &atrium_xrpc::XrpcRequest {
4825 method: http::Method::POST,
4826 nsid: crate::com::atproto::server::request_password_reset::NSID
4827 .into(),
4828 parameters: None,
4829 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4830 encoding: Some(String::from("application/json")),
4831 },
4832 )
4833 .await?;
4834 match response {
4835 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4836 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4837 }
4838 }
4839 pub async fn reserve_signing_key(
4841 &self,
4842 input: crate::com::atproto::server::reserve_signing_key::Input,
4843 ) -> atrium_xrpc::Result<
4844 crate::com::atproto::server::reserve_signing_key::Output,
4845 crate::com::atproto::server::reserve_signing_key::Error,
4846 > {
4847 let response = self
4848 .xrpc
4849 .send_xrpc::<
4850 (),
4851 _,
4852 _,
4853 _,
4854 >(
4855 &atrium_xrpc::XrpcRequest {
4856 method: http::Method::POST,
4857 nsid: crate::com::atproto::server::reserve_signing_key::NSID.into(),
4858 parameters: None,
4859 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4860 encoding: Some(String::from("application/json")),
4861 },
4862 )
4863 .await?;
4864 match response {
4865 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
4866 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4867 }
4868 }
4869 pub async fn reset_password(
4871 &self,
4872 input: crate::com::atproto::server::reset_password::Input,
4873 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::reset_password::Error> {
4874 let response = self
4875 .xrpc
4876 .send_xrpc::<
4877 (),
4878 _,
4879 (),
4880 _,
4881 >(
4882 &atrium_xrpc::XrpcRequest {
4883 method: http::Method::POST,
4884 nsid: crate::com::atproto::server::reset_password::NSID.into(),
4885 parameters: None,
4886 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4887 encoding: Some(String::from("application/json")),
4888 },
4889 )
4890 .await?;
4891 match response {
4892 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4893 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4894 }
4895 }
4896 pub async fn revoke_app_password(
4898 &self,
4899 input: crate::com::atproto::server::revoke_app_password::Input,
4900 ) -> atrium_xrpc::Result<
4901 (),
4902 crate::com::atproto::server::revoke_app_password::Error,
4903 > {
4904 let response = self
4905 .xrpc
4906 .send_xrpc::<
4907 (),
4908 _,
4909 (),
4910 _,
4911 >(
4912 &atrium_xrpc::XrpcRequest {
4913 method: http::Method::POST,
4914 nsid: crate::com::atproto::server::revoke_app_password::NSID.into(),
4915 parameters: None,
4916 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4917 encoding: Some(String::from("application/json")),
4918 },
4919 )
4920 .await?;
4921 match response {
4922 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4923 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4924 }
4925 }
4926 pub async fn update_email(
4928 &self,
4929 input: crate::com::atproto::server::update_email::Input,
4930 ) -> atrium_xrpc::Result<(), crate::com::atproto::server::update_email::Error> {
4931 let response = self
4932 .xrpc
4933 .send_xrpc::<
4934 (),
4935 _,
4936 (),
4937 _,
4938 >(
4939 &atrium_xrpc::XrpcRequest {
4940 method: http::Method::POST,
4941 nsid: crate::com::atproto::server::update_email::NSID.into(),
4942 parameters: None,
4943 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
4944 encoding: Some(String::from("application/json")),
4945 },
4946 )
4947 .await?;
4948 match response {
4949 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
4950 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4951 }
4952 }
4953}
4954impl<T> com::atproto::sync::Service<T>
4955where
4956 T: atrium_xrpc::XrpcClient + Send + Sync,
4957{
4958 #[allow(unused_variables)]
4959 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
4960 Self {
4961 xrpc,
4962 _phantom: core::marker::PhantomData,
4963 }
4964 }
4965 pub async fn get_blob(
4967 &self,
4968 params: crate::com::atproto::sync::get_blob::Parameters,
4969 ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_blob::Error> {
4970 let response = self
4971 .xrpc
4972 .send_xrpc::<
4973 _,
4974 (),
4975 (),
4976 _,
4977 >(
4978 &atrium_xrpc::XrpcRequest {
4979 method: http::Method::GET,
4980 nsid: crate::com::atproto::sync::get_blob::NSID.into(),
4981 parameters: Some(params),
4982 input: None,
4983 encoding: None,
4984 },
4985 )
4986 .await?;
4987 match response {
4988 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
4989 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
4990 }
4991 }
4992 pub async fn get_blocks(
4994 &self,
4995 params: crate::com::atproto::sync::get_blocks::Parameters,
4996 ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_blocks::Error> {
4997 let response = self
4998 .xrpc
4999 .send_xrpc::<
5000 _,
5001 (),
5002 (),
5003 _,
5004 >(
5005 &atrium_xrpc::XrpcRequest {
5006 method: http::Method::GET,
5007 nsid: crate::com::atproto::sync::get_blocks::NSID.into(),
5008 parameters: Some(params),
5009 input: None,
5010 encoding: None,
5011 },
5012 )
5013 .await?;
5014 match response {
5015 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
5016 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5017 }
5018 }
5019 pub async fn get_checkout(
5021 &self,
5022 params: crate::com::atproto::sync::get_checkout::Parameters,
5023 ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_checkout::Error> {
5024 let response = self
5025 .xrpc
5026 .send_xrpc::<
5027 _,
5028 (),
5029 (),
5030 _,
5031 >(
5032 &atrium_xrpc::XrpcRequest {
5033 method: http::Method::GET,
5034 nsid: crate::com::atproto::sync::get_checkout::NSID.into(),
5035 parameters: Some(params),
5036 input: None,
5037 encoding: None,
5038 },
5039 )
5040 .await?;
5041 match response {
5042 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
5043 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5044 }
5045 }
5046 pub async fn get_head(
5048 &self,
5049 params: crate::com::atproto::sync::get_head::Parameters,
5050 ) -> atrium_xrpc::Result<
5051 crate::com::atproto::sync::get_head::Output,
5052 crate::com::atproto::sync::get_head::Error,
5053 > {
5054 let response = self
5055 .xrpc
5056 .send_xrpc::<
5057 _,
5058 (),
5059 _,
5060 _,
5061 >(
5062 &atrium_xrpc::XrpcRequest {
5063 method: http::Method::GET,
5064 nsid: crate::com::atproto::sync::get_head::NSID.into(),
5065 parameters: Some(params),
5066 input: None,
5067 encoding: None,
5068 },
5069 )
5070 .await?;
5071 match response {
5072 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5073 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5074 }
5075 }
5076 pub async fn get_latest_commit(
5078 &self,
5079 params: crate::com::atproto::sync::get_latest_commit::Parameters,
5080 ) -> atrium_xrpc::Result<
5081 crate::com::atproto::sync::get_latest_commit::Output,
5082 crate::com::atproto::sync::get_latest_commit::Error,
5083 > {
5084 let response = self
5085 .xrpc
5086 .send_xrpc::<
5087 _,
5088 (),
5089 _,
5090 _,
5091 >(
5092 &atrium_xrpc::XrpcRequest {
5093 method: http::Method::GET,
5094 nsid: crate::com::atproto::sync::get_latest_commit::NSID.into(),
5095 parameters: Some(params),
5096 input: None,
5097 encoding: None,
5098 },
5099 )
5100 .await?;
5101 match response {
5102 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5103 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5104 }
5105 }
5106 pub async fn get_record(
5108 &self,
5109 params: crate::com::atproto::sync::get_record::Parameters,
5110 ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_record::Error> {
5111 let response = self
5112 .xrpc
5113 .send_xrpc::<
5114 _,
5115 (),
5116 (),
5117 _,
5118 >(
5119 &atrium_xrpc::XrpcRequest {
5120 method: http::Method::GET,
5121 nsid: crate::com::atproto::sync::get_record::NSID.into(),
5122 parameters: Some(params),
5123 input: None,
5124 encoding: None,
5125 },
5126 )
5127 .await?;
5128 match response {
5129 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
5130 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5131 }
5132 }
5133 pub async fn get_repo(
5135 &self,
5136 params: crate::com::atproto::sync::get_repo::Parameters,
5137 ) -> atrium_xrpc::Result<Vec<u8>, crate::com::atproto::sync::get_repo::Error> {
5138 let response = self
5139 .xrpc
5140 .send_xrpc::<
5141 _,
5142 (),
5143 (),
5144 _,
5145 >(
5146 &atrium_xrpc::XrpcRequest {
5147 method: http::Method::GET,
5148 nsid: crate::com::atproto::sync::get_repo::NSID.into(),
5149 parameters: Some(params),
5150 input: None,
5151 encoding: None,
5152 },
5153 )
5154 .await?;
5155 match response {
5156 atrium_xrpc::OutputDataOrBytes::Bytes(bytes) => Ok(bytes),
5157 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5158 }
5159 }
5160 pub async fn get_repo_status(
5162 &self,
5163 params: crate::com::atproto::sync::get_repo_status::Parameters,
5164 ) -> atrium_xrpc::Result<
5165 crate::com::atproto::sync::get_repo_status::Output,
5166 crate::com::atproto::sync::get_repo_status::Error,
5167 > {
5168 let response = self
5169 .xrpc
5170 .send_xrpc::<
5171 _,
5172 (),
5173 _,
5174 _,
5175 >(
5176 &atrium_xrpc::XrpcRequest {
5177 method: http::Method::GET,
5178 nsid: crate::com::atproto::sync::get_repo_status::NSID.into(),
5179 parameters: Some(params),
5180 input: None,
5181 encoding: None,
5182 },
5183 )
5184 .await?;
5185 match response {
5186 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5187 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5188 }
5189 }
5190 pub async fn list_blobs(
5192 &self,
5193 params: crate::com::atproto::sync::list_blobs::Parameters,
5194 ) -> atrium_xrpc::Result<
5195 crate::com::atproto::sync::list_blobs::Output,
5196 crate::com::atproto::sync::list_blobs::Error,
5197 > {
5198 let response = self
5199 .xrpc
5200 .send_xrpc::<
5201 _,
5202 (),
5203 _,
5204 _,
5205 >(
5206 &atrium_xrpc::XrpcRequest {
5207 method: http::Method::GET,
5208 nsid: crate::com::atproto::sync::list_blobs::NSID.into(),
5209 parameters: Some(params),
5210 input: None,
5211 encoding: None,
5212 },
5213 )
5214 .await?;
5215 match response {
5216 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5217 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5218 }
5219 }
5220 pub async fn list_repos(
5222 &self,
5223 params: crate::com::atproto::sync::list_repos::Parameters,
5224 ) -> atrium_xrpc::Result<
5225 crate::com::atproto::sync::list_repos::Output,
5226 crate::com::atproto::sync::list_repos::Error,
5227 > {
5228 let response = self
5229 .xrpc
5230 .send_xrpc::<
5231 _,
5232 (),
5233 _,
5234 _,
5235 >(
5236 &atrium_xrpc::XrpcRequest {
5237 method: http::Method::GET,
5238 nsid: crate::com::atproto::sync::list_repos::NSID.into(),
5239 parameters: Some(params),
5240 input: None,
5241 encoding: None,
5242 },
5243 )
5244 .await?;
5245 match response {
5246 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5247 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5248 }
5249 }
5250 pub async fn list_repos_by_collection(
5252 &self,
5253 params: crate::com::atproto::sync::list_repos_by_collection::Parameters,
5254 ) -> atrium_xrpc::Result<
5255 crate::com::atproto::sync::list_repos_by_collection::Output,
5256 crate::com::atproto::sync::list_repos_by_collection::Error,
5257 > {
5258 let response = self
5259 .xrpc
5260 .send_xrpc::<
5261 _,
5262 (),
5263 _,
5264 _,
5265 >(
5266 &atrium_xrpc::XrpcRequest {
5267 method: http::Method::GET,
5268 nsid: crate::com::atproto::sync::list_repos_by_collection::NSID
5269 .into(),
5270 parameters: Some(params),
5271 input: None,
5272 encoding: None,
5273 },
5274 )
5275 .await?;
5276 match response {
5277 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5278 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5279 }
5280 }
5281 pub async fn notify_of_update(
5283 &self,
5284 input: crate::com::atproto::sync::notify_of_update::Input,
5285 ) -> atrium_xrpc::Result<(), crate::com::atproto::sync::notify_of_update::Error> {
5286 let response = self
5287 .xrpc
5288 .send_xrpc::<
5289 (),
5290 _,
5291 (),
5292 _,
5293 >(
5294 &atrium_xrpc::XrpcRequest {
5295 method: http::Method::POST,
5296 nsid: crate::com::atproto::sync::notify_of_update::NSID.into(),
5297 parameters: None,
5298 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5299 encoding: Some(String::from("application/json")),
5300 },
5301 )
5302 .await?;
5303 match response {
5304 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
5305 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5306 }
5307 }
5308 pub async fn request_crawl(
5310 &self,
5311 input: crate::com::atproto::sync::request_crawl::Input,
5312 ) -> atrium_xrpc::Result<(), crate::com::atproto::sync::request_crawl::Error> {
5313 let response = self
5314 .xrpc
5315 .send_xrpc::<
5316 (),
5317 _,
5318 (),
5319 _,
5320 >(
5321 &atrium_xrpc::XrpcRequest {
5322 method: http::Method::POST,
5323 nsid: crate::com::atproto::sync::request_crawl::NSID.into(),
5324 parameters: None,
5325 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5326 encoding: Some(String::from("application/json")),
5327 },
5328 )
5329 .await?;
5330 match response {
5331 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
5332 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5333 }
5334 }
5335}
5336impl<T> com::atproto::temp::Service<T>
5337where
5338 T: atrium_xrpc::XrpcClient + Send + Sync,
5339{
5340 #[allow(unused_variables)]
5341 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5342 Self {
5343 xrpc,
5344 _phantom: core::marker::PhantomData,
5345 }
5346 }
5347 pub async fn add_reserved_handle(
5349 &self,
5350 input: crate::com::atproto::temp::add_reserved_handle::Input,
5351 ) -> atrium_xrpc::Result<
5352 crate::com::atproto::temp::add_reserved_handle::Output,
5353 crate::com::atproto::temp::add_reserved_handle::Error,
5354 > {
5355 let response = self
5356 .xrpc
5357 .send_xrpc::<
5358 (),
5359 _,
5360 _,
5361 _,
5362 >(
5363 &atrium_xrpc::XrpcRequest {
5364 method: http::Method::POST,
5365 nsid: crate::com::atproto::temp::add_reserved_handle::NSID.into(),
5366 parameters: None,
5367 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5368 encoding: Some(String::from("application/json")),
5369 },
5370 )
5371 .await?;
5372 match response {
5373 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5374 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5375 }
5376 }
5377 pub async fn check_signup_queue(
5379 &self,
5380 ) -> atrium_xrpc::Result<
5381 crate::com::atproto::temp::check_signup_queue::Output,
5382 crate::com::atproto::temp::check_signup_queue::Error,
5383 > {
5384 let response = self
5385 .xrpc
5386 .send_xrpc::<
5387 (),
5388 (),
5389 _,
5390 _,
5391 >(
5392 &atrium_xrpc::XrpcRequest {
5393 method: http::Method::GET,
5394 nsid: crate::com::atproto::temp::check_signup_queue::NSID.into(),
5395 parameters: None,
5396 input: None,
5397 encoding: None,
5398 },
5399 )
5400 .await?;
5401 match response {
5402 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5403 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5404 }
5405 }
5406 pub async fn fetch_labels(
5408 &self,
5409 params: crate::com::atproto::temp::fetch_labels::Parameters,
5410 ) -> atrium_xrpc::Result<
5411 crate::com::atproto::temp::fetch_labels::Output,
5412 crate::com::atproto::temp::fetch_labels::Error,
5413 > {
5414 let response = self
5415 .xrpc
5416 .send_xrpc::<
5417 _,
5418 (),
5419 _,
5420 _,
5421 >(
5422 &atrium_xrpc::XrpcRequest {
5423 method: http::Method::GET,
5424 nsid: crate::com::atproto::temp::fetch_labels::NSID.into(),
5425 parameters: Some(params),
5426 input: None,
5427 encoding: None,
5428 },
5429 )
5430 .await?;
5431 match response {
5432 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5433 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5434 }
5435 }
5436 pub async fn request_phone_verification(
5438 &self,
5439 input: crate::com::atproto::temp::request_phone_verification::Input,
5440 ) -> atrium_xrpc::Result<
5441 (),
5442 crate::com::atproto::temp::request_phone_verification::Error,
5443 > {
5444 let response = self
5445 .xrpc
5446 .send_xrpc::<
5447 (),
5448 _,
5449 (),
5450 _,
5451 >(
5452 &atrium_xrpc::XrpcRequest {
5453 method: http::Method::POST,
5454 nsid: crate::com::atproto::temp::request_phone_verification::NSID
5455 .into(),
5456 parameters: None,
5457 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5458 encoding: Some(String::from("application/json")),
5459 },
5460 )
5461 .await?;
5462 match response {
5463 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
5464 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5465 }
5466 }
5467}
5468impl<T> tools::Service<T>
5469where
5470 T: atrium_xrpc::XrpcClient + Send + Sync,
5471{
5472 #[allow(unused_variables)]
5473 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5474 Self {
5475 #[cfg(feature = "namespace-toolsozone")]
5476 ozone: tools::ozone::Service::new(std::sync::Arc::clone(&xrpc)),
5477 _phantom: core::marker::PhantomData,
5478 }
5479 }
5480}
5481#[cfg(feature = "namespace-toolsozone")]
5482impl<T> tools::ozone::Service<T>
5483where
5484 T: atrium_xrpc::XrpcClient + Send + Sync,
5485{
5486 #[allow(unused_variables)]
5487 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5488 Self {
5489 communication: tools::ozone::communication::Service::new(
5490 std::sync::Arc::clone(&xrpc),
5491 ),
5492 moderation: tools::ozone::moderation::Service::new(
5493 std::sync::Arc::clone(&xrpc),
5494 ),
5495 server: tools::ozone::server::Service::new(std::sync::Arc::clone(&xrpc)),
5496 set: tools::ozone::set::Service::new(std::sync::Arc::clone(&xrpc)),
5497 setting: tools::ozone::setting::Service::new(std::sync::Arc::clone(&xrpc)),
5498 signature: tools::ozone::signature::Service::new(
5499 std::sync::Arc::clone(&xrpc),
5500 ),
5501 team: tools::ozone::team::Service::new(std::sync::Arc::clone(&xrpc)),
5502 _phantom: core::marker::PhantomData,
5503 }
5504 }
5505}
5506#[cfg(feature = "namespace-toolsozone")]
5507impl<T> tools::ozone::communication::Service<T>
5508where
5509 T: atrium_xrpc::XrpcClient + Send + Sync,
5510{
5511 #[allow(unused_variables)]
5512 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5513 Self {
5514 xrpc,
5515 _phantom: core::marker::PhantomData,
5516 }
5517 }
5518 pub async fn create_template(
5520 &self,
5521 input: crate::tools::ozone::communication::create_template::Input,
5522 ) -> atrium_xrpc::Result<
5523 crate::tools::ozone::communication::create_template::Output,
5524 crate::tools::ozone::communication::create_template::Error,
5525 > {
5526 let response = self
5527 .xrpc
5528 .send_xrpc::<
5529 (),
5530 _,
5531 _,
5532 _,
5533 >(
5534 &atrium_xrpc::XrpcRequest {
5535 method: http::Method::POST,
5536 nsid: crate::tools::ozone::communication::create_template::NSID
5537 .into(),
5538 parameters: None,
5539 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5540 encoding: Some(String::from("application/json")),
5541 },
5542 )
5543 .await?;
5544 match response {
5545 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5546 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5547 }
5548 }
5549 pub async fn delete_template(
5551 &self,
5552 input: crate::tools::ozone::communication::delete_template::Input,
5553 ) -> atrium_xrpc::Result<
5554 (),
5555 crate::tools::ozone::communication::delete_template::Error,
5556 > {
5557 let response = self
5558 .xrpc
5559 .send_xrpc::<
5560 (),
5561 _,
5562 (),
5563 _,
5564 >(
5565 &atrium_xrpc::XrpcRequest {
5566 method: http::Method::POST,
5567 nsid: crate::tools::ozone::communication::delete_template::NSID
5568 .into(),
5569 parameters: None,
5570 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5571 encoding: Some(String::from("application/json")),
5572 },
5573 )
5574 .await?;
5575 match response {
5576 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
5577 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5578 }
5579 }
5580 pub async fn list_templates(
5582 &self,
5583 ) -> atrium_xrpc::Result<
5584 crate::tools::ozone::communication::list_templates::Output,
5585 crate::tools::ozone::communication::list_templates::Error,
5586 > {
5587 let response = self
5588 .xrpc
5589 .send_xrpc::<
5590 (),
5591 (),
5592 _,
5593 _,
5594 >(
5595 &atrium_xrpc::XrpcRequest {
5596 method: http::Method::GET,
5597 nsid: crate::tools::ozone::communication::list_templates::NSID
5598 .into(),
5599 parameters: None,
5600 input: None,
5601 encoding: None,
5602 },
5603 )
5604 .await?;
5605 match response {
5606 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5607 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5608 }
5609 }
5610 pub async fn update_template(
5612 &self,
5613 input: crate::tools::ozone::communication::update_template::Input,
5614 ) -> atrium_xrpc::Result<
5615 crate::tools::ozone::communication::update_template::Output,
5616 crate::tools::ozone::communication::update_template::Error,
5617 > {
5618 let response = self
5619 .xrpc
5620 .send_xrpc::<
5621 (),
5622 _,
5623 _,
5624 _,
5625 >(
5626 &atrium_xrpc::XrpcRequest {
5627 method: http::Method::POST,
5628 nsid: crate::tools::ozone::communication::update_template::NSID
5629 .into(),
5630 parameters: None,
5631 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5632 encoding: Some(String::from("application/json")),
5633 },
5634 )
5635 .await?;
5636 match response {
5637 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5638 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5639 }
5640 }
5641}
5642#[cfg(feature = "namespace-toolsozone")]
5643impl<T> tools::ozone::moderation::Service<T>
5644where
5645 T: atrium_xrpc::XrpcClient + Send + Sync,
5646{
5647 #[allow(unused_variables)]
5648 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5649 Self {
5650 xrpc,
5651 _phantom: core::marker::PhantomData,
5652 }
5653 }
5654 pub async fn emit_event(
5656 &self,
5657 input: crate::tools::ozone::moderation::emit_event::Input,
5658 ) -> atrium_xrpc::Result<
5659 crate::tools::ozone::moderation::emit_event::Output,
5660 crate::tools::ozone::moderation::emit_event::Error,
5661 > {
5662 let response = self
5663 .xrpc
5664 .send_xrpc::<
5665 (),
5666 _,
5667 _,
5668 _,
5669 >(
5670 &atrium_xrpc::XrpcRequest {
5671 method: http::Method::POST,
5672 nsid: crate::tools::ozone::moderation::emit_event::NSID.into(),
5673 parameters: None,
5674 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
5675 encoding: Some(String::from("application/json")),
5676 },
5677 )
5678 .await?;
5679 match response {
5680 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5681 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5682 }
5683 }
5684 pub async fn get_event(
5686 &self,
5687 params: crate::tools::ozone::moderation::get_event::Parameters,
5688 ) -> atrium_xrpc::Result<
5689 crate::tools::ozone::moderation::get_event::Output,
5690 crate::tools::ozone::moderation::get_event::Error,
5691 > {
5692 let response = self
5693 .xrpc
5694 .send_xrpc::<
5695 _,
5696 (),
5697 _,
5698 _,
5699 >(
5700 &atrium_xrpc::XrpcRequest {
5701 method: http::Method::GET,
5702 nsid: crate::tools::ozone::moderation::get_event::NSID.into(),
5703 parameters: Some(params),
5704 input: None,
5705 encoding: None,
5706 },
5707 )
5708 .await?;
5709 match response {
5710 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5711 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5712 }
5713 }
5714 pub async fn get_record(
5716 &self,
5717 params: crate::tools::ozone::moderation::get_record::Parameters,
5718 ) -> atrium_xrpc::Result<
5719 crate::tools::ozone::moderation::get_record::Output,
5720 crate::tools::ozone::moderation::get_record::Error,
5721 > {
5722 let response = self
5723 .xrpc
5724 .send_xrpc::<
5725 _,
5726 (),
5727 _,
5728 _,
5729 >(
5730 &atrium_xrpc::XrpcRequest {
5731 method: http::Method::GET,
5732 nsid: crate::tools::ozone::moderation::get_record::NSID.into(),
5733 parameters: Some(params),
5734 input: None,
5735 encoding: None,
5736 },
5737 )
5738 .await?;
5739 match response {
5740 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5741 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5742 }
5743 }
5744 pub async fn get_records(
5746 &self,
5747 params: crate::tools::ozone::moderation::get_records::Parameters,
5748 ) -> atrium_xrpc::Result<
5749 crate::tools::ozone::moderation::get_records::Output,
5750 crate::tools::ozone::moderation::get_records::Error,
5751 > {
5752 let response = self
5753 .xrpc
5754 .send_xrpc::<
5755 _,
5756 (),
5757 _,
5758 _,
5759 >(
5760 &atrium_xrpc::XrpcRequest {
5761 method: http::Method::GET,
5762 nsid: crate::tools::ozone::moderation::get_records::NSID.into(),
5763 parameters: Some(params),
5764 input: None,
5765 encoding: None,
5766 },
5767 )
5768 .await?;
5769 match response {
5770 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5771 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5772 }
5773 }
5774 pub async fn get_repo(
5776 &self,
5777 params: crate::tools::ozone::moderation::get_repo::Parameters,
5778 ) -> atrium_xrpc::Result<
5779 crate::tools::ozone::moderation::get_repo::Output,
5780 crate::tools::ozone::moderation::get_repo::Error,
5781 > {
5782 let response = self
5783 .xrpc
5784 .send_xrpc::<
5785 _,
5786 (),
5787 _,
5788 _,
5789 >(
5790 &atrium_xrpc::XrpcRequest {
5791 method: http::Method::GET,
5792 nsid: crate::tools::ozone::moderation::get_repo::NSID.into(),
5793 parameters: Some(params),
5794 input: None,
5795 encoding: None,
5796 },
5797 )
5798 .await?;
5799 match response {
5800 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5801 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5802 }
5803 }
5804 pub async fn get_reporter_stats(
5806 &self,
5807 params: crate::tools::ozone::moderation::get_reporter_stats::Parameters,
5808 ) -> atrium_xrpc::Result<
5809 crate::tools::ozone::moderation::get_reporter_stats::Output,
5810 crate::tools::ozone::moderation::get_reporter_stats::Error,
5811 > {
5812 let response = self
5813 .xrpc
5814 .send_xrpc::<
5815 _,
5816 (),
5817 _,
5818 _,
5819 >(
5820 &atrium_xrpc::XrpcRequest {
5821 method: http::Method::GET,
5822 nsid: crate::tools::ozone::moderation::get_reporter_stats::NSID
5823 .into(),
5824 parameters: Some(params),
5825 input: None,
5826 encoding: None,
5827 },
5828 )
5829 .await?;
5830 match response {
5831 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5832 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5833 }
5834 }
5835 pub async fn get_repos(
5837 &self,
5838 params: crate::tools::ozone::moderation::get_repos::Parameters,
5839 ) -> atrium_xrpc::Result<
5840 crate::tools::ozone::moderation::get_repos::Output,
5841 crate::tools::ozone::moderation::get_repos::Error,
5842 > {
5843 let response = self
5844 .xrpc
5845 .send_xrpc::<
5846 _,
5847 (),
5848 _,
5849 _,
5850 >(
5851 &atrium_xrpc::XrpcRequest {
5852 method: http::Method::GET,
5853 nsid: crate::tools::ozone::moderation::get_repos::NSID.into(),
5854 parameters: Some(params),
5855 input: None,
5856 encoding: None,
5857 },
5858 )
5859 .await?;
5860 match response {
5861 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5862 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5863 }
5864 }
5865 pub async fn get_subjects(
5867 &self,
5868 params: crate::tools::ozone::moderation::get_subjects::Parameters,
5869 ) -> atrium_xrpc::Result<
5870 crate::tools::ozone::moderation::get_subjects::Output,
5871 crate::tools::ozone::moderation::get_subjects::Error,
5872 > {
5873 let response = self
5874 .xrpc
5875 .send_xrpc::<
5876 _,
5877 (),
5878 _,
5879 _,
5880 >(
5881 &atrium_xrpc::XrpcRequest {
5882 method: http::Method::GET,
5883 nsid: crate::tools::ozone::moderation::get_subjects::NSID.into(),
5884 parameters: Some(params),
5885 input: None,
5886 encoding: None,
5887 },
5888 )
5889 .await?;
5890 match response {
5891 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5892 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5893 }
5894 }
5895 pub async fn query_events(
5897 &self,
5898 params: crate::tools::ozone::moderation::query_events::Parameters,
5899 ) -> atrium_xrpc::Result<
5900 crate::tools::ozone::moderation::query_events::Output,
5901 crate::tools::ozone::moderation::query_events::Error,
5902 > {
5903 let response = self
5904 .xrpc
5905 .send_xrpc::<
5906 _,
5907 (),
5908 _,
5909 _,
5910 >(
5911 &atrium_xrpc::XrpcRequest {
5912 method: http::Method::GET,
5913 nsid: crate::tools::ozone::moderation::query_events::NSID.into(),
5914 parameters: Some(params),
5915 input: None,
5916 encoding: None,
5917 },
5918 )
5919 .await?;
5920 match response {
5921 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5922 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5923 }
5924 }
5925 pub async fn query_statuses(
5927 &self,
5928 params: crate::tools::ozone::moderation::query_statuses::Parameters,
5929 ) -> atrium_xrpc::Result<
5930 crate::tools::ozone::moderation::query_statuses::Output,
5931 crate::tools::ozone::moderation::query_statuses::Error,
5932 > {
5933 let response = self
5934 .xrpc
5935 .send_xrpc::<
5936 _,
5937 (),
5938 _,
5939 _,
5940 >(
5941 &atrium_xrpc::XrpcRequest {
5942 method: http::Method::GET,
5943 nsid: crate::tools::ozone::moderation::query_statuses::NSID.into(),
5944 parameters: Some(params),
5945 input: None,
5946 encoding: None,
5947 },
5948 )
5949 .await?;
5950 match response {
5951 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5952 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5953 }
5954 }
5955 pub async fn search_repos(
5957 &self,
5958 params: crate::tools::ozone::moderation::search_repos::Parameters,
5959 ) -> atrium_xrpc::Result<
5960 crate::tools::ozone::moderation::search_repos::Output,
5961 crate::tools::ozone::moderation::search_repos::Error,
5962 > {
5963 let response = self
5964 .xrpc
5965 .send_xrpc::<
5966 _,
5967 (),
5968 _,
5969 _,
5970 >(
5971 &atrium_xrpc::XrpcRequest {
5972 method: http::Method::GET,
5973 nsid: crate::tools::ozone::moderation::search_repos::NSID.into(),
5974 parameters: Some(params),
5975 input: None,
5976 encoding: None,
5977 },
5978 )
5979 .await?;
5980 match response {
5981 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
5982 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
5983 }
5984 }
5985}
5986#[cfg(feature = "namespace-toolsozone")]
5987impl<T> tools::ozone::server::Service<T>
5988where
5989 T: atrium_xrpc::XrpcClient + Send + Sync,
5990{
5991 #[allow(unused_variables)]
5992 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
5993 Self {
5994 xrpc,
5995 _phantom: core::marker::PhantomData,
5996 }
5997 }
5998 pub async fn get_config(
6000 &self,
6001 ) -> atrium_xrpc::Result<
6002 crate::tools::ozone::server::get_config::Output,
6003 crate::tools::ozone::server::get_config::Error,
6004 > {
6005 let response = self
6006 .xrpc
6007 .send_xrpc::<
6008 (),
6009 (),
6010 _,
6011 _,
6012 >(
6013 &atrium_xrpc::XrpcRequest {
6014 method: http::Method::GET,
6015 nsid: crate::tools::ozone::server::get_config::NSID.into(),
6016 parameters: None,
6017 input: None,
6018 encoding: None,
6019 },
6020 )
6021 .await?;
6022 match response {
6023 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6024 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6025 }
6026 }
6027}
6028#[cfg(feature = "namespace-toolsozone")]
6029impl<T> tools::ozone::set::Service<T>
6030where
6031 T: atrium_xrpc::XrpcClient + Send + Sync,
6032{
6033 #[allow(unused_variables)]
6034 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
6035 Self {
6036 xrpc,
6037 _phantom: core::marker::PhantomData,
6038 }
6039 }
6040 pub async fn add_values(
6042 &self,
6043 input: crate::tools::ozone::set::add_values::Input,
6044 ) -> atrium_xrpc::Result<(), crate::tools::ozone::set::add_values::Error> {
6045 let response = self
6046 .xrpc
6047 .send_xrpc::<
6048 (),
6049 _,
6050 (),
6051 _,
6052 >(
6053 &atrium_xrpc::XrpcRequest {
6054 method: http::Method::POST,
6055 nsid: crate::tools::ozone::set::add_values::NSID.into(),
6056 parameters: None,
6057 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6058 encoding: Some(String::from("application/json")),
6059 },
6060 )
6061 .await?;
6062 match response {
6063 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
6064 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6065 }
6066 }
6067 pub async fn delete_set(
6069 &self,
6070 input: crate::tools::ozone::set::delete_set::Input,
6071 ) -> atrium_xrpc::Result<
6072 crate::tools::ozone::set::delete_set::Output,
6073 crate::tools::ozone::set::delete_set::Error,
6074 > {
6075 let response = self
6076 .xrpc
6077 .send_xrpc::<
6078 (),
6079 _,
6080 _,
6081 _,
6082 >(
6083 &atrium_xrpc::XrpcRequest {
6084 method: http::Method::POST,
6085 nsid: crate::tools::ozone::set::delete_set::NSID.into(),
6086 parameters: None,
6087 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6088 encoding: Some(String::from("application/json")),
6089 },
6090 )
6091 .await?;
6092 match response {
6093 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6094 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6095 }
6096 }
6097 pub async fn delete_values(
6099 &self,
6100 input: crate::tools::ozone::set::delete_values::Input,
6101 ) -> atrium_xrpc::Result<(), crate::tools::ozone::set::delete_values::Error> {
6102 let response = self
6103 .xrpc
6104 .send_xrpc::<
6105 (),
6106 _,
6107 (),
6108 _,
6109 >(
6110 &atrium_xrpc::XrpcRequest {
6111 method: http::Method::POST,
6112 nsid: crate::tools::ozone::set::delete_values::NSID.into(),
6113 parameters: None,
6114 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6115 encoding: Some(String::from("application/json")),
6116 },
6117 )
6118 .await?;
6119 match response {
6120 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
6121 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6122 }
6123 }
6124 pub async fn get_values(
6126 &self,
6127 params: crate::tools::ozone::set::get_values::Parameters,
6128 ) -> atrium_xrpc::Result<
6129 crate::tools::ozone::set::get_values::Output,
6130 crate::tools::ozone::set::get_values::Error,
6131 > {
6132 let response = self
6133 .xrpc
6134 .send_xrpc::<
6135 _,
6136 (),
6137 _,
6138 _,
6139 >(
6140 &atrium_xrpc::XrpcRequest {
6141 method: http::Method::GET,
6142 nsid: crate::tools::ozone::set::get_values::NSID.into(),
6143 parameters: Some(params),
6144 input: None,
6145 encoding: None,
6146 },
6147 )
6148 .await?;
6149 match response {
6150 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6151 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6152 }
6153 }
6154 pub async fn query_sets(
6156 &self,
6157 params: crate::tools::ozone::set::query_sets::Parameters,
6158 ) -> atrium_xrpc::Result<
6159 crate::tools::ozone::set::query_sets::Output,
6160 crate::tools::ozone::set::query_sets::Error,
6161 > {
6162 let response = self
6163 .xrpc
6164 .send_xrpc::<
6165 _,
6166 (),
6167 _,
6168 _,
6169 >(
6170 &atrium_xrpc::XrpcRequest {
6171 method: http::Method::GET,
6172 nsid: crate::tools::ozone::set::query_sets::NSID.into(),
6173 parameters: Some(params),
6174 input: None,
6175 encoding: None,
6176 },
6177 )
6178 .await?;
6179 match response {
6180 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6181 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6182 }
6183 }
6184 pub async fn upsert_set(
6186 &self,
6187 input: crate::tools::ozone::set::upsert_set::Input,
6188 ) -> atrium_xrpc::Result<
6189 crate::tools::ozone::set::upsert_set::Output,
6190 crate::tools::ozone::set::upsert_set::Error,
6191 > {
6192 let response = self
6193 .xrpc
6194 .send_xrpc::<
6195 (),
6196 _,
6197 _,
6198 _,
6199 >(
6200 &atrium_xrpc::XrpcRequest {
6201 method: http::Method::POST,
6202 nsid: crate::tools::ozone::set::upsert_set::NSID.into(),
6203 parameters: None,
6204 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6205 encoding: Some(String::from("application/json")),
6206 },
6207 )
6208 .await?;
6209 match response {
6210 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6211 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6212 }
6213 }
6214}
6215#[cfg(feature = "namespace-toolsozone")]
6216impl<T> tools::ozone::setting::Service<T>
6217where
6218 T: atrium_xrpc::XrpcClient + Send + Sync,
6219{
6220 #[allow(unused_variables)]
6221 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
6222 Self {
6223 xrpc,
6224 _phantom: core::marker::PhantomData,
6225 }
6226 }
6227 pub async fn list_options(
6229 &self,
6230 params: crate::tools::ozone::setting::list_options::Parameters,
6231 ) -> atrium_xrpc::Result<
6232 crate::tools::ozone::setting::list_options::Output,
6233 crate::tools::ozone::setting::list_options::Error,
6234 > {
6235 let response = self
6236 .xrpc
6237 .send_xrpc::<
6238 _,
6239 (),
6240 _,
6241 _,
6242 >(
6243 &atrium_xrpc::XrpcRequest {
6244 method: http::Method::GET,
6245 nsid: crate::tools::ozone::setting::list_options::NSID.into(),
6246 parameters: Some(params),
6247 input: None,
6248 encoding: None,
6249 },
6250 )
6251 .await?;
6252 match response {
6253 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6254 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6255 }
6256 }
6257 pub async fn remove_options(
6259 &self,
6260 input: crate::tools::ozone::setting::remove_options::Input,
6261 ) -> atrium_xrpc::Result<
6262 crate::tools::ozone::setting::remove_options::Output,
6263 crate::tools::ozone::setting::remove_options::Error,
6264 > {
6265 let response = self
6266 .xrpc
6267 .send_xrpc::<
6268 (),
6269 _,
6270 _,
6271 _,
6272 >(
6273 &atrium_xrpc::XrpcRequest {
6274 method: http::Method::POST,
6275 nsid: crate::tools::ozone::setting::remove_options::NSID.into(),
6276 parameters: None,
6277 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6278 encoding: Some(String::from("application/json")),
6279 },
6280 )
6281 .await?;
6282 match response {
6283 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6284 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6285 }
6286 }
6287 pub async fn upsert_option(
6289 &self,
6290 input: crate::tools::ozone::setting::upsert_option::Input,
6291 ) -> atrium_xrpc::Result<
6292 crate::tools::ozone::setting::upsert_option::Output,
6293 crate::tools::ozone::setting::upsert_option::Error,
6294 > {
6295 let response = self
6296 .xrpc
6297 .send_xrpc::<
6298 (),
6299 _,
6300 _,
6301 _,
6302 >(
6303 &atrium_xrpc::XrpcRequest {
6304 method: http::Method::POST,
6305 nsid: crate::tools::ozone::setting::upsert_option::NSID.into(),
6306 parameters: None,
6307 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6308 encoding: Some(String::from("application/json")),
6309 },
6310 )
6311 .await?;
6312 match response {
6313 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6314 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6315 }
6316 }
6317}
6318#[cfg(feature = "namespace-toolsozone")]
6319impl<T> tools::ozone::signature::Service<T>
6320where
6321 T: atrium_xrpc::XrpcClient + Send + Sync,
6322{
6323 #[allow(unused_variables)]
6324 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
6325 Self {
6326 xrpc,
6327 _phantom: core::marker::PhantomData,
6328 }
6329 }
6330 pub async fn find_correlation(
6332 &self,
6333 params: crate::tools::ozone::signature::find_correlation::Parameters,
6334 ) -> atrium_xrpc::Result<
6335 crate::tools::ozone::signature::find_correlation::Output,
6336 crate::tools::ozone::signature::find_correlation::Error,
6337 > {
6338 let response = self
6339 .xrpc
6340 .send_xrpc::<
6341 _,
6342 (),
6343 _,
6344 _,
6345 >(
6346 &atrium_xrpc::XrpcRequest {
6347 method: http::Method::GET,
6348 nsid: crate::tools::ozone::signature::find_correlation::NSID.into(),
6349 parameters: Some(params),
6350 input: None,
6351 encoding: None,
6352 },
6353 )
6354 .await?;
6355 match response {
6356 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6357 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6358 }
6359 }
6360 pub async fn find_related_accounts(
6362 &self,
6363 params: crate::tools::ozone::signature::find_related_accounts::Parameters,
6364 ) -> atrium_xrpc::Result<
6365 crate::tools::ozone::signature::find_related_accounts::Output,
6366 crate::tools::ozone::signature::find_related_accounts::Error,
6367 > {
6368 let response = self
6369 .xrpc
6370 .send_xrpc::<
6371 _,
6372 (),
6373 _,
6374 _,
6375 >(
6376 &atrium_xrpc::XrpcRequest {
6377 method: http::Method::GET,
6378 nsid: crate::tools::ozone::signature::find_related_accounts::NSID
6379 .into(),
6380 parameters: Some(params),
6381 input: None,
6382 encoding: None,
6383 },
6384 )
6385 .await?;
6386 match response {
6387 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6388 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6389 }
6390 }
6391 pub async fn search_accounts(
6393 &self,
6394 params: crate::tools::ozone::signature::search_accounts::Parameters,
6395 ) -> atrium_xrpc::Result<
6396 crate::tools::ozone::signature::search_accounts::Output,
6397 crate::tools::ozone::signature::search_accounts::Error,
6398 > {
6399 let response = self
6400 .xrpc
6401 .send_xrpc::<
6402 _,
6403 (),
6404 _,
6405 _,
6406 >(
6407 &atrium_xrpc::XrpcRequest {
6408 method: http::Method::GET,
6409 nsid: crate::tools::ozone::signature::search_accounts::NSID.into(),
6410 parameters: Some(params),
6411 input: None,
6412 encoding: None,
6413 },
6414 )
6415 .await?;
6416 match response {
6417 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6418 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6419 }
6420 }
6421}
6422#[cfg(feature = "namespace-toolsozone")]
6423impl<T> tools::ozone::team::Service<T>
6424where
6425 T: atrium_xrpc::XrpcClient + Send + Sync,
6426{
6427 #[allow(unused_variables)]
6428 pub(crate) fn new(xrpc: std::sync::Arc<T>) -> Self {
6429 Self {
6430 xrpc,
6431 _phantom: core::marker::PhantomData,
6432 }
6433 }
6434 pub async fn add_member(
6436 &self,
6437 input: crate::tools::ozone::team::add_member::Input,
6438 ) -> atrium_xrpc::Result<
6439 crate::tools::ozone::team::add_member::Output,
6440 crate::tools::ozone::team::add_member::Error,
6441 > {
6442 let response = self
6443 .xrpc
6444 .send_xrpc::<
6445 (),
6446 _,
6447 _,
6448 _,
6449 >(
6450 &atrium_xrpc::XrpcRequest {
6451 method: http::Method::POST,
6452 nsid: crate::tools::ozone::team::add_member::NSID.into(),
6453 parameters: None,
6454 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6455 encoding: Some(String::from("application/json")),
6456 },
6457 )
6458 .await?;
6459 match response {
6460 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6461 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6462 }
6463 }
6464 pub async fn delete_member(
6466 &self,
6467 input: crate::tools::ozone::team::delete_member::Input,
6468 ) -> atrium_xrpc::Result<(), crate::tools::ozone::team::delete_member::Error> {
6469 let response = self
6470 .xrpc
6471 .send_xrpc::<
6472 (),
6473 _,
6474 (),
6475 _,
6476 >(
6477 &atrium_xrpc::XrpcRequest {
6478 method: http::Method::POST,
6479 nsid: crate::tools::ozone::team::delete_member::NSID.into(),
6480 parameters: None,
6481 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6482 encoding: Some(String::from("application/json")),
6483 },
6484 )
6485 .await?;
6486 match response {
6487 atrium_xrpc::OutputDataOrBytes::Bytes(_) => Ok(()),
6488 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6489 }
6490 }
6491 pub async fn list_members(
6493 &self,
6494 params: crate::tools::ozone::team::list_members::Parameters,
6495 ) -> atrium_xrpc::Result<
6496 crate::tools::ozone::team::list_members::Output,
6497 crate::tools::ozone::team::list_members::Error,
6498 > {
6499 let response = self
6500 .xrpc
6501 .send_xrpc::<
6502 _,
6503 (),
6504 _,
6505 _,
6506 >(
6507 &atrium_xrpc::XrpcRequest {
6508 method: http::Method::GET,
6509 nsid: crate::tools::ozone::team::list_members::NSID.into(),
6510 parameters: Some(params),
6511 input: None,
6512 encoding: None,
6513 },
6514 )
6515 .await?;
6516 match response {
6517 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6518 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6519 }
6520 }
6521 pub async fn update_member(
6523 &self,
6524 input: crate::tools::ozone::team::update_member::Input,
6525 ) -> atrium_xrpc::Result<
6526 crate::tools::ozone::team::update_member::Output,
6527 crate::tools::ozone::team::update_member::Error,
6528 > {
6529 let response = self
6530 .xrpc
6531 .send_xrpc::<
6532 (),
6533 _,
6534 _,
6535 _,
6536 >(
6537 &atrium_xrpc::XrpcRequest {
6538 method: http::Method::POST,
6539 nsid: crate::tools::ozone::team::update_member::NSID.into(),
6540 parameters: None,
6541 input: Some(atrium_xrpc::InputDataOrBytes::Data(input)),
6542 encoding: Some(String::from("application/json")),
6543 },
6544 )
6545 .await?;
6546 match response {
6547 atrium_xrpc::OutputDataOrBytes::Data(data) => Ok(data),
6548 _ => Err(atrium_xrpc::Error::UnexpectedResponseType),
6549 }
6550 }
6551}