1#[allow(missing_docs)] #[non_exhaustive]
4#[derive(std::clone::Clone, std::cmp::PartialEq)]
5pub struct RequestMatchmakerPlayerOutput {}
6impl std::fmt::Debug for RequestMatchmakerPlayerOutput {
7 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8 let mut formatter = f.debug_struct("RequestMatchmakerPlayerOutput");
9 formatter.finish()
10 }
11}
12pub mod request_matchmaker_player_output {
14 #[non_exhaustive]
16 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
17 pub struct Builder {}
18 impl Builder {
19 pub fn build(self) -> crate::output::RequestMatchmakerPlayerOutput {
21 crate::output::RequestMatchmakerPlayerOutput {}
22 }
23 }
24}
25impl RequestMatchmakerPlayerOutput {
26 pub fn builder() -> crate::output::request_matchmaker_player_output::Builder {
28 crate::output::request_matchmaker_player_output::Builder::default()
29 }
30}
31
32#[allow(missing_docs)] #[non_exhaustive]
34#[derive(std::clone::Clone, std::cmp::PartialEq)]
35pub struct FindMatchmakerLobbyForPartyOutput {}
36impl std::fmt::Debug for FindMatchmakerLobbyForPartyOutput {
37 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38 let mut formatter = f.debug_struct("FindMatchmakerLobbyForPartyOutput");
39 formatter.finish()
40 }
41}
42pub mod find_matchmaker_lobby_for_party_output {
44 #[non_exhaustive]
46 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
47 pub struct Builder {}
48 impl Builder {
49 pub fn build(self) -> crate::output::FindMatchmakerLobbyForPartyOutput {
51 crate::output::FindMatchmakerLobbyForPartyOutput {}
52 }
53 }
54}
55impl FindMatchmakerLobbyForPartyOutput {
56 pub fn builder() -> crate::output::find_matchmaker_lobby_for_party_output::Builder {
58 crate::output::find_matchmaker_lobby_for_party_output::Builder::default()
59 }
60}
61
62#[allow(missing_docs)] #[non_exhaustive]
64#[derive(std::clone::Clone, std::cmp::PartialEq)]
65pub struct JoinMatchmakerLobbyForPartyOutput {}
66impl std::fmt::Debug for JoinMatchmakerLobbyForPartyOutput {
67 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68 let mut formatter = f.debug_struct("JoinMatchmakerLobbyForPartyOutput");
69 formatter.finish()
70 }
71}
72pub mod join_matchmaker_lobby_for_party_output {
74 #[non_exhaustive]
76 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
77 pub struct Builder {}
78 impl Builder {
79 pub fn build(self) -> crate::output::JoinMatchmakerLobbyForPartyOutput {
81 crate::output::JoinMatchmakerLobbyForPartyOutput {}
82 }
83 }
84}
85impl JoinMatchmakerLobbyForPartyOutput {
86 pub fn builder() -> crate::output::join_matchmaker_lobby_for_party_output::Builder {
88 crate::output::join_matchmaker_lobby_for_party_output::Builder::default()
89 }
90}
91
92#[allow(missing_docs)] #[non_exhaustive]
94#[derive(std::clone::Clone, std::cmp::PartialEq)]
95pub struct SetPartyToIdleOutput {}
96impl std::fmt::Debug for SetPartyToIdleOutput {
97 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98 let mut formatter = f.debug_struct("SetPartyToIdleOutput");
99 formatter.finish()
100 }
101}
102pub mod set_party_to_idle_output {
104 #[non_exhaustive]
106 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
107 pub struct Builder {}
108 impl Builder {
109 pub fn build(self) -> crate::output::SetPartyToIdleOutput {
111 crate::output::SetPartyToIdleOutput {}
112 }
113 }
114}
115impl SetPartyToIdleOutput {
116 pub fn builder() -> crate::output::set_party_to_idle_output::Builder {
118 crate::output::set_party_to_idle_output::Builder::default()
119 }
120}
121
122#[allow(missing_docs)] #[non_exhaustive]
124#[derive(std::clone::Clone, std::cmp::PartialEq)]
125pub struct SendJoinRequestOutput {}
126impl std::fmt::Debug for SendJoinRequestOutput {
127 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
128 let mut formatter = f.debug_struct("SendJoinRequestOutput");
129 formatter.finish()
130 }
131}
132pub mod send_join_request_output {
134 #[non_exhaustive]
136 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
137 pub struct Builder {}
138 impl Builder {
139 pub fn build(self) -> crate::output::SendJoinRequestOutput {
141 crate::output::SendJoinRequestOutput {}
142 }
143 }
144}
145impl SendJoinRequestOutput {
146 pub fn builder() -> crate::output::send_join_request_output::Builder {
148 crate::output::send_join_request_output::Builder::default()
149 }
150}
151
152#[allow(missing_docs)] #[non_exhaustive]
154#[derive(std::clone::Clone, std::cmp::PartialEq)]
155pub struct GetPartyFromInviteOutput {
156 pub party: std::option::Option<crate::model::PartySummary>,
158}
159impl GetPartyFromInviteOutput {
160 pub fn party(&self) -> std::option::Option<&crate::model::PartySummary> {
162 self.party.as_ref()
163 }
164}
165impl std::fmt::Debug for GetPartyFromInviteOutput {
166 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 let mut formatter = f.debug_struct("GetPartyFromInviteOutput");
168 formatter.field("party", &self.party);
169 formatter.finish()
170 }
171}
172pub mod get_party_from_invite_output {
174 #[non_exhaustive]
176 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
177 pub struct Builder {
178 pub(crate) party: std::option::Option<crate::model::PartySummary>,
179 }
180 impl Builder {
181 pub fn party(mut self, input: crate::model::PartySummary) -> Self {
183 self.party = Some(input);
184 self
185 }
186 pub fn set_party(mut self, input: std::option::Option<crate::model::PartySummary>) -> Self {
188 self.party = input;
189 self
190 }
191 pub fn build(self) -> crate::output::GetPartyFromInviteOutput {
193 crate::output::GetPartyFromInviteOutput { party: self.party }
194 }
195 }
196}
197impl GetPartyFromInviteOutput {
198 pub fn builder() -> crate::output::get_party_from_invite_output::Builder {
200 crate::output::get_party_from_invite_output::Builder::default()
201 }
202}
203
204#[allow(missing_docs)] #[non_exhaustive]
206#[derive(std::clone::Clone, std::cmp::PartialEq)]
207pub struct RevokePartyInviteOutput {}
208impl std::fmt::Debug for RevokePartyInviteOutput {
209 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
210 let mut formatter = f.debug_struct("RevokePartyInviteOutput");
211 formatter.finish()
212 }
213}
214pub mod revoke_party_invite_output {
216 #[non_exhaustive]
218 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
219 pub struct Builder {}
220 impl Builder {
221 pub fn build(self) -> crate::output::RevokePartyInviteOutput {
223 crate::output::RevokePartyInviteOutput {}
224 }
225 }
226}
227impl RevokePartyInviteOutput {
228 pub fn builder() -> crate::output::revoke_party_invite_output::Builder {
230 crate::output::revoke_party_invite_output::Builder::default()
231 }
232}
233
234#[allow(missing_docs)] #[non_exhaustive]
236#[derive(std::clone::Clone, std::cmp::PartialEq)]
237pub struct KickMemberOutput {}
238impl std::fmt::Debug for KickMemberOutput {
239 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
240 let mut formatter = f.debug_struct("KickMemberOutput");
241 formatter.finish()
242 }
243}
244pub mod kick_member_output {
246 #[non_exhaustive]
248 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
249 pub struct Builder {}
250 impl Builder {
251 pub fn build(self) -> crate::output::KickMemberOutput {
253 crate::output::KickMemberOutput {}
254 }
255 }
256}
257impl KickMemberOutput {
258 pub fn builder() -> crate::output::kick_member_output::Builder {
260 crate::output::kick_member_output::Builder::default()
261 }
262}
263
264#[allow(missing_docs)] #[non_exhaustive]
266#[derive(std::clone::Clone, std::cmp::PartialEq)]
267pub struct TransferPartyOwnershipOutput {}
268impl std::fmt::Debug for TransferPartyOwnershipOutput {
269 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270 let mut formatter = f.debug_struct("TransferPartyOwnershipOutput");
271 formatter.finish()
272 }
273}
274pub mod transfer_party_ownership_output {
276 #[non_exhaustive]
278 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
279 pub struct Builder {}
280 impl Builder {
281 pub fn build(self) -> crate::output::TransferPartyOwnershipOutput {
283 crate::output::TransferPartyOwnershipOutput {}
284 }
285 }
286}
287impl TransferPartyOwnershipOutput {
288 pub fn builder() -> crate::output::transfer_party_ownership_output::Builder {
290 crate::output::transfer_party_ownership_output::Builder::default()
291 }
292}
293
294#[allow(missing_docs)] #[non_exhaustive]
296#[derive(std::clone::Clone, std::cmp::PartialEq)]
297pub struct SetPartyPublicityOutput {}
298impl std::fmt::Debug for SetPartyPublicityOutput {
299 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
300 let mut formatter = f.debug_struct("SetPartyPublicityOutput");
301 formatter.finish()
302 }
303}
304pub mod set_party_publicity_output {
306 #[non_exhaustive]
308 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
309 pub struct Builder {}
310 impl Builder {
311 pub fn build(self) -> crate::output::SetPartyPublicityOutput {
313 crate::output::SetPartyPublicityOutput {}
314 }
315 }
316}
317impl SetPartyPublicityOutput {
318 pub fn builder() -> crate::output::set_party_publicity_output::Builder {
320 crate::output::set_party_publicity_output::Builder::default()
321 }
322}
323
324#[allow(missing_docs)] #[non_exhaustive]
326#[derive(std::clone::Clone, std::cmp::PartialEq)]
327pub struct LeavePartyOutput {}
328impl std::fmt::Debug for LeavePartyOutput {
329 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
330 let mut formatter = f.debug_struct("LeavePartyOutput");
331 formatter.finish()
332 }
333}
334pub mod leave_party_output {
336 #[non_exhaustive]
338 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
339 pub struct Builder {}
340 impl Builder {
341 pub fn build(self) -> crate::output::LeavePartyOutput {
343 crate::output::LeavePartyOutput {}
344 }
345 }
346}
347impl LeavePartyOutput {
348 pub fn builder() -> crate::output::leave_party_output::Builder {
350 crate::output::leave_party_output::Builder::default()
351 }
352}
353
354#[allow(missing_docs)] #[non_exhaustive]
356#[derive(std::clone::Clone, std::cmp::PartialEq)]
357pub struct JoinPartyOutput {
358 pub party_id: std::option::Option<std::string::String>,
360}
361impl JoinPartyOutput {
362 pub fn party_id(&self) -> std::option::Option<&str> {
364 self.party_id.as_deref()
365 }
366}
367impl std::fmt::Debug for JoinPartyOutput {
368 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
369 let mut formatter = f.debug_struct("JoinPartyOutput");
370 formatter.field("party_id", &self.party_id);
371 formatter.finish()
372 }
373}
374pub mod join_party_output {
376 #[non_exhaustive]
378 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
379 pub struct Builder {
380 pub(crate) party_id: std::option::Option<std::string::String>,
381 }
382 impl Builder {
383 pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
385 self.party_id = Some(input.into());
386 self
387 }
388 pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
390 self.party_id = input;
391 self
392 }
393 pub fn build(self) -> crate::output::JoinPartyOutput {
395 crate::output::JoinPartyOutput {
396 party_id: self.party_id,
397 }
398 }
399 }
400}
401impl JoinPartyOutput {
402 pub fn builder() -> crate::output::join_party_output::Builder {
404 crate::output::join_party_output::Builder::default()
405 }
406}
407
408#[allow(missing_docs)] #[non_exhaustive]
410#[derive(std::clone::Clone, std::cmp::PartialEq)]
411pub struct CreatePartyInviteOutput {
412 pub invite: std::option::Option<crate::model::CreatedInvite>,
414}
415impl CreatePartyInviteOutput {
416 pub fn invite(&self) -> std::option::Option<&crate::model::CreatedInvite> {
418 self.invite.as_ref()
419 }
420}
421impl std::fmt::Debug for CreatePartyInviteOutput {
422 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
423 let mut formatter = f.debug_struct("CreatePartyInviteOutput");
424 formatter.field("invite", &self.invite);
425 formatter.finish()
426 }
427}
428pub mod create_party_invite_output {
430 #[non_exhaustive]
432 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
433 pub struct Builder {
434 pub(crate) invite: std::option::Option<crate::model::CreatedInvite>,
435 }
436 impl Builder {
437 pub fn invite(mut self, input: crate::model::CreatedInvite) -> Self {
439 self.invite = Some(input);
440 self
441 }
442 pub fn set_invite(
444 mut self,
445 input: std::option::Option<crate::model::CreatedInvite>,
446 ) -> Self {
447 self.invite = input;
448 self
449 }
450 pub fn build(self) -> crate::output::CreatePartyInviteOutput {
452 crate::output::CreatePartyInviteOutput {
453 invite: self.invite,
454 }
455 }
456 }
457}
458impl CreatePartyInviteOutput {
459 pub fn builder() -> crate::output::create_party_invite_output::Builder {
461 crate::output::create_party_invite_output::Builder::default()
462 }
463}
464
465#[allow(missing_docs)] #[non_exhaustive]
467#[derive(std::clone::Clone, std::cmp::PartialEq)]
468pub struct CreatePartyOutput {
469 pub party_id: std::option::Option<std::string::String>,
471 #[allow(missing_docs)] pub invites: std::option::Option<std::vec::Vec<crate::model::CreatedInvite>>,
473}
474impl CreatePartyOutput {
475 pub fn party_id(&self) -> std::option::Option<&str> {
477 self.party_id.as_deref()
478 }
479 #[allow(missing_docs)] pub fn invites(&self) -> std::option::Option<&[crate::model::CreatedInvite]> {
481 self.invites.as_deref()
482 }
483}
484impl std::fmt::Debug for CreatePartyOutput {
485 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
486 let mut formatter = f.debug_struct("CreatePartyOutput");
487 formatter.field("party_id", &self.party_id);
488 formatter.field("invites", &self.invites);
489 formatter.finish()
490 }
491}
492pub mod create_party_output {
494 #[non_exhaustive]
496 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
497 pub struct Builder {
498 pub(crate) party_id: std::option::Option<std::string::String>,
499 pub(crate) invites: std::option::Option<std::vec::Vec<crate::model::CreatedInvite>>,
500 }
501 impl Builder {
502 pub fn party_id(mut self, input: impl Into<std::string::String>) -> Self {
504 self.party_id = Some(input.into());
505 self
506 }
507 pub fn set_party_id(mut self, input: std::option::Option<std::string::String>) -> Self {
509 self.party_id = input;
510 self
511 }
512 pub fn invites(mut self, input: crate::model::CreatedInvite) -> Self {
517 let mut v = self.invites.unwrap_or_default();
518 v.push(input);
519 self.invites = Some(v);
520 self
521 }
522 #[allow(missing_docs)] pub fn set_invites(
524 mut self,
525 input: std::option::Option<std::vec::Vec<crate::model::CreatedInvite>>,
526 ) -> Self {
527 self.invites = input;
528 self
529 }
530 pub fn build(self) -> crate::output::CreatePartyOutput {
532 crate::output::CreatePartyOutput {
533 party_id: self.party_id,
534 invites: self.invites,
535 }
536 }
537 }
538}
539impl CreatePartyOutput {
540 pub fn builder() -> crate::output::create_party_output::Builder {
542 crate::output::create_party_output::Builder::default()
543 }
544}
545
546#[allow(missing_docs)] #[non_exhaustive]
548#[derive(std::clone::Clone, std::cmp::PartialEq)]
549pub struct GetPartySelfProfileOutput {
550 #[allow(missing_docs)] pub party: std::option::Option<crate::model::PartyProfile>,
552 pub watch: std::option::Option<crate::model::WatchResponse>,
554}
555impl GetPartySelfProfileOutput {
556 #[allow(missing_docs)] pub fn party(&self) -> std::option::Option<&crate::model::PartyProfile> {
558 self.party.as_ref()
559 }
560 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
562 self.watch.as_ref()
563 }
564}
565impl std::fmt::Debug for GetPartySelfProfileOutput {
566 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
567 let mut formatter = f.debug_struct("GetPartySelfProfileOutput");
568 formatter.field("party", &self.party);
569 formatter.field("watch", &self.watch);
570 formatter.finish()
571 }
572}
573pub mod get_party_self_profile_output {
575 #[non_exhaustive]
577 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
578 pub struct Builder {
579 pub(crate) party: std::option::Option<crate::model::PartyProfile>,
580 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
581 }
582 impl Builder {
583 #[allow(missing_docs)] pub fn party(mut self, input: crate::model::PartyProfile) -> Self {
585 self.party = Some(input);
586 self
587 }
588 #[allow(missing_docs)] pub fn set_party(mut self, input: std::option::Option<crate::model::PartyProfile>) -> Self {
590 self.party = input;
591 self
592 }
593 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
595 self.watch = Some(input);
596 self
597 }
598 pub fn set_watch(
600 mut self,
601 input: std::option::Option<crate::model::WatchResponse>,
602 ) -> Self {
603 self.watch = input;
604 self
605 }
606 pub fn build(self) -> crate::output::GetPartySelfProfileOutput {
608 crate::output::GetPartySelfProfileOutput {
609 party: self.party,
610 watch: self.watch,
611 }
612 }
613 }
614}
615impl GetPartySelfProfileOutput {
616 pub fn builder() -> crate::output::get_party_self_profile_output::Builder {
618 crate::output::get_party_self_profile_output::Builder::default()
619 }
620}
621
622#[allow(missing_docs)] #[non_exhaustive]
624#[derive(std::clone::Clone, std::cmp::PartialEq)]
625pub struct GetPartyProfileOutput {
626 #[allow(missing_docs)] pub party: std::option::Option<crate::model::PartyProfile>,
628 pub watch: std::option::Option<crate::model::WatchResponse>,
630}
631impl GetPartyProfileOutput {
632 #[allow(missing_docs)] pub fn party(&self) -> std::option::Option<&crate::model::PartyProfile> {
634 self.party.as_ref()
635 }
636 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
638 self.watch.as_ref()
639 }
640}
641impl std::fmt::Debug for GetPartyProfileOutput {
642 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
643 let mut formatter = f.debug_struct("GetPartyProfileOutput");
644 formatter.field("party", &self.party);
645 formatter.field("watch", &self.watch);
646 formatter.finish()
647 }
648}
649pub mod get_party_profile_output {
651 #[non_exhaustive]
653 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
654 pub struct Builder {
655 pub(crate) party: std::option::Option<crate::model::PartyProfile>,
656 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
657 }
658 impl Builder {
659 #[allow(missing_docs)] pub fn party(mut self, input: crate::model::PartyProfile) -> Self {
661 self.party = Some(input);
662 self
663 }
664 #[allow(missing_docs)] pub fn set_party(mut self, input: std::option::Option<crate::model::PartyProfile>) -> Self {
666 self.party = input;
667 self
668 }
669 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
671 self.watch = Some(input);
672 self
673 }
674 pub fn set_watch(
676 mut self,
677 input: std::option::Option<crate::model::WatchResponse>,
678 ) -> Self {
679 self.watch = input;
680 self
681 }
682 pub fn build(self) -> crate::output::GetPartyProfileOutput {
684 crate::output::GetPartyProfileOutput {
685 party: self.party,
686 watch: self.watch,
687 }
688 }
689 }
690}
691impl GetPartyProfileOutput {
692 pub fn builder() -> crate::output::get_party_profile_output::Builder {
694 crate::output::get_party_profile_output::Builder::default()
695 }
696}
697
698#[allow(missing_docs)] #[non_exhaustive]
700#[derive(std::clone::Clone, std::cmp::PartialEq)]
701pub struct GetPartySelfSummaryOutput {
702 pub party: std::option::Option<crate::model::PartySummary>,
704 pub watch: std::option::Option<crate::model::WatchResponse>,
706}
707impl GetPartySelfSummaryOutput {
708 pub fn party(&self) -> std::option::Option<&crate::model::PartySummary> {
710 self.party.as_ref()
711 }
712 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
714 self.watch.as_ref()
715 }
716}
717impl std::fmt::Debug for GetPartySelfSummaryOutput {
718 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
719 let mut formatter = f.debug_struct("GetPartySelfSummaryOutput");
720 formatter.field("party", &self.party);
721 formatter.field("watch", &self.watch);
722 formatter.finish()
723 }
724}
725pub mod get_party_self_summary_output {
727 #[non_exhaustive]
729 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
730 pub struct Builder {
731 pub(crate) party: std::option::Option<crate::model::PartySummary>,
732 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
733 }
734 impl Builder {
735 pub fn party(mut self, input: crate::model::PartySummary) -> Self {
737 self.party = Some(input);
738 self
739 }
740 pub fn set_party(mut self, input: std::option::Option<crate::model::PartySummary>) -> Self {
742 self.party = input;
743 self
744 }
745 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
747 self.watch = Some(input);
748 self
749 }
750 pub fn set_watch(
752 mut self,
753 input: std::option::Option<crate::model::WatchResponse>,
754 ) -> Self {
755 self.watch = input;
756 self
757 }
758 pub fn build(self) -> crate::output::GetPartySelfSummaryOutput {
760 crate::output::GetPartySelfSummaryOutput {
761 party: self.party,
762 watch: self.watch,
763 }
764 }
765 }
766}
767impl GetPartySelfSummaryOutput {
768 pub fn builder() -> crate::output::get_party_self_summary_output::Builder {
770 crate::output::get_party_self_summary_output::Builder::default()
771 }
772}
773
774#[allow(missing_docs)] #[non_exhaustive]
776#[derive(std::clone::Clone, std::cmp::PartialEq)]
777pub struct GetPartySummaryOutput {
778 pub party: std::option::Option<crate::model::PartySummary>,
780 pub watch: std::option::Option<crate::model::WatchResponse>,
782}
783impl GetPartySummaryOutput {
784 pub fn party(&self) -> std::option::Option<&crate::model::PartySummary> {
786 self.party.as_ref()
787 }
788 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
790 self.watch.as_ref()
791 }
792}
793impl std::fmt::Debug for GetPartySummaryOutput {
794 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
795 let mut formatter = f.debug_struct("GetPartySummaryOutput");
796 formatter.field("party", &self.party);
797 formatter.field("watch", &self.watch);
798 formatter.finish()
799 }
800}
801pub mod get_party_summary_output {
803 #[non_exhaustive]
805 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
806 pub struct Builder {
807 pub(crate) party: std::option::Option<crate::model::PartySummary>,
808 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
809 }
810 impl Builder {
811 pub fn party(mut self, input: crate::model::PartySummary) -> Self {
813 self.party = Some(input);
814 self
815 }
816 pub fn set_party(mut self, input: std::option::Option<crate::model::PartySummary>) -> Self {
818 self.party = input;
819 self
820 }
821 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
823 self.watch = Some(input);
824 self
825 }
826 pub fn set_watch(
828 mut self,
829 input: std::option::Option<crate::model::WatchResponse>,
830 ) -> Self {
831 self.watch = input;
832 self
833 }
834 pub fn build(self) -> crate::output::GetPartySummaryOutput {
836 crate::output::GetPartySummaryOutput {
837 party: self.party,
838 watch: self.watch,
839 }
840 }
841 }
842}
843impl GetPartySummaryOutput {
844 pub fn builder() -> crate::output::get_party_summary_output::Builder {
846 crate::output::get_party_summary_output::Builder::default()
847 }
848}