1#[allow(missing_docs)] #[non_exhaustive]
4#[derive(std::clone::Clone, std::cmp::PartialEq)]
5pub struct ResolveGroupJoinRequestOutput {}
6impl std::fmt::Debug for ResolveGroupJoinRequestOutput {
7 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8 let mut formatter = f.debug_struct("ResolveGroupJoinRequestOutput");
9 formatter.finish()
10 }
11}
12pub mod resolve_group_join_request_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::ResolveGroupJoinRequestOutput {
21 crate::output::ResolveGroupJoinRequestOutput {}
22 }
23 }
24}
25impl ResolveGroupJoinRequestOutput {
26 pub fn builder() -> crate::output::resolve_group_join_request_output::Builder {
28 crate::output::resolve_group_join_request_output::Builder::default()
29 }
30}
31
32#[allow(missing_docs)] #[non_exhaustive]
34#[derive(std::clone::Clone, std::cmp::PartialEq)]
35pub struct CreateGroupJoinRequestOutput {}
36impl std::fmt::Debug for CreateGroupJoinRequestOutput {
37 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38 let mut formatter = f.debug_struct("CreateGroupJoinRequestOutput");
39 formatter.finish()
40 }
41}
42pub mod create_group_join_request_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::CreateGroupJoinRequestOutput {
51 crate::output::CreateGroupJoinRequestOutput {}
52 }
53 }
54}
55impl CreateGroupJoinRequestOutput {
56 pub fn builder() -> crate::output::create_group_join_request_output::Builder {
58 crate::output::create_group_join_request_output::Builder::default()
59 }
60}
61
62#[allow(missing_docs)] #[non_exhaustive]
64#[derive(std::clone::Clone, std::cmp::PartialEq)]
65pub struct GetGroupInviteOutput {
66 pub group: std::option::Option<crate::model::GroupHandle>,
68}
69impl GetGroupInviteOutput {
70 pub fn group(&self) -> std::option::Option<&crate::model::GroupHandle> {
72 self.group.as_ref()
73 }
74}
75impl std::fmt::Debug for GetGroupInviteOutput {
76 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 let mut formatter = f.debug_struct("GetGroupInviteOutput");
78 formatter.field("group", &self.group);
79 formatter.finish()
80 }
81}
82pub mod get_group_invite_output {
84 #[non_exhaustive]
86 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
87 pub struct Builder {
88 pub(crate) group: std::option::Option<crate::model::GroupHandle>,
89 }
90 impl Builder {
91 pub fn group(mut self, input: crate::model::GroupHandle) -> Self {
93 self.group = Some(input);
94 self
95 }
96 pub fn set_group(mut self, input: std::option::Option<crate::model::GroupHandle>) -> Self {
98 self.group = input;
99 self
100 }
101 pub fn build(self) -> crate::output::GetGroupInviteOutput {
103 crate::output::GetGroupInviteOutput { group: self.group }
104 }
105 }
106}
107impl GetGroupInviteOutput {
108 pub fn builder() -> crate::output::get_group_invite_output::Builder {
110 crate::output::get_group_invite_output::Builder::default()
111 }
112}
113
114#[allow(missing_docs)] #[non_exhaustive]
116#[derive(std::clone::Clone, std::cmp::PartialEq)]
117pub struct ConsumeGroupInviteOutput {
118 pub group_id: std::option::Option<std::string::String>,
120}
121impl ConsumeGroupInviteOutput {
122 pub fn group_id(&self) -> std::option::Option<&str> {
124 self.group_id.as_deref()
125 }
126}
127impl std::fmt::Debug for ConsumeGroupInviteOutput {
128 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
129 let mut formatter = f.debug_struct("ConsumeGroupInviteOutput");
130 formatter.field("group_id", &self.group_id);
131 formatter.finish()
132 }
133}
134pub mod consume_group_invite_output {
136 #[non_exhaustive]
138 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
139 pub struct Builder {
140 pub(crate) group_id: std::option::Option<std::string::String>,
141 }
142 impl Builder {
143 pub fn group_id(mut self, input: impl Into<std::string::String>) -> Self {
145 self.group_id = Some(input.into());
146 self
147 }
148 pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
150 self.group_id = input;
151 self
152 }
153 pub fn build(self) -> crate::output::ConsumeGroupInviteOutput {
155 crate::output::ConsumeGroupInviteOutput {
156 group_id: self.group_id,
157 }
158 }
159 }
160}
161impl ConsumeGroupInviteOutput {
162 pub fn builder() -> crate::output::consume_group_invite_output::Builder {
164 crate::output::consume_group_invite_output::Builder::default()
165 }
166}
167
168#[allow(missing_docs)] #[non_exhaustive]
170#[derive(std::clone::Clone, std::cmp::PartialEq)]
171pub struct CreateGroupInviteOutput {
172 pub code: std::option::Option<std::string::String>,
174}
175impl CreateGroupInviteOutput {
176 pub fn code(&self) -> std::option::Option<&str> {
178 self.code.as_deref()
179 }
180}
181impl std::fmt::Debug for CreateGroupInviteOutput {
182 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
183 let mut formatter = f.debug_struct("CreateGroupInviteOutput");
184 formatter.field("code", &self.code);
185 formatter.finish()
186 }
187}
188pub mod create_group_invite_output {
190 #[non_exhaustive]
192 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
193 pub struct Builder {
194 pub(crate) code: std::option::Option<std::string::String>,
195 }
196 impl Builder {
197 pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
199 self.code = Some(input.into());
200 self
201 }
202 pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
204 self.code = input;
205 self
206 }
207 pub fn build(self) -> crate::output::CreateGroupInviteOutput {
209 crate::output::CreateGroupInviteOutput { code: self.code }
210 }
211 }
212}
213impl CreateGroupInviteOutput {
214 pub fn builder() -> crate::output::create_group_invite_output::Builder {
216 crate::output::create_group_invite_output::Builder::default()
217 }
218}
219
220#[allow(missing_docs)] #[non_exhaustive]
222#[derive(std::clone::Clone, std::cmp::PartialEq)]
223pub struct LeaveGroupOutput {}
224impl std::fmt::Debug for LeaveGroupOutput {
225 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
226 let mut formatter = f.debug_struct("LeaveGroupOutput");
227 formatter.finish()
228 }
229}
230pub mod leave_group_output {
232 #[non_exhaustive]
234 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
235 pub struct Builder {}
236 impl Builder {
237 pub fn build(self) -> crate::output::LeaveGroupOutput {
239 crate::output::LeaveGroupOutput {}
240 }
241 }
242}
243impl LeaveGroupOutput {
244 pub fn builder() -> crate::output::leave_group_output::Builder {
246 crate::output::leave_group_output::Builder::default()
247 }
248}
249
250#[allow(missing_docs)] #[non_exhaustive]
252#[derive(std::clone::Clone, std::cmp::PartialEq)]
253pub struct JoinGroupOutput {}
254impl std::fmt::Debug for JoinGroupOutput {
255 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
256 let mut formatter = f.debug_struct("JoinGroupOutput");
257 formatter.finish()
258 }
259}
260pub mod join_group_output {
262 #[non_exhaustive]
264 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
265 pub struct Builder {}
266 impl Builder {
267 pub fn build(self) -> crate::output::JoinGroupOutput {
269 crate::output::JoinGroupOutput {}
270 }
271 }
272}
273impl JoinGroupOutput {
274 pub fn builder() -> crate::output::join_group_output::Builder {
276 crate::output::join_group_output::Builder::default()
277 }
278}
279
280#[allow(missing_docs)] #[non_exhaustive]
282#[derive(std::clone::Clone, std::cmp::PartialEq)]
283pub struct CompleteGroupAvatarUploadOutput {}
284impl std::fmt::Debug for CompleteGroupAvatarUploadOutput {
285 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
286 let mut formatter = f.debug_struct("CompleteGroupAvatarUploadOutput");
287 formatter.finish()
288 }
289}
290pub mod complete_group_avatar_upload_output {
292 #[non_exhaustive]
294 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
295 pub struct Builder {}
296 impl Builder {
297 pub fn build(self) -> crate::output::CompleteGroupAvatarUploadOutput {
299 crate::output::CompleteGroupAvatarUploadOutput {}
300 }
301 }
302}
303impl CompleteGroupAvatarUploadOutput {
304 pub fn builder() -> crate::output::complete_group_avatar_upload_output::Builder {
306 crate::output::complete_group_avatar_upload_output::Builder::default()
307 }
308}
309
310#[allow(missing_docs)] #[non_exhaustive]
312#[derive(std::clone::Clone, std::cmp::PartialEq)]
313pub struct PrepareGroupAvatarUploadOutput {
314 pub upload_id: std::option::Option<std::string::String>,
316 pub presigned_request: std::option::Option<crate::model::UploadPresignedRequest>,
318}
319impl PrepareGroupAvatarUploadOutput {
320 pub fn upload_id(&self) -> std::option::Option<&str> {
322 self.upload_id.as_deref()
323 }
324 pub fn presigned_request(&self) -> std::option::Option<&crate::model::UploadPresignedRequest> {
326 self.presigned_request.as_ref()
327 }
328}
329impl std::fmt::Debug for PrepareGroupAvatarUploadOutput {
330 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
331 let mut formatter = f.debug_struct("PrepareGroupAvatarUploadOutput");
332 formatter.field("upload_id", &self.upload_id);
333 formatter.field("presigned_request", &self.presigned_request);
334 formatter.finish()
335 }
336}
337pub mod prepare_group_avatar_upload_output {
339 #[non_exhaustive]
341 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
342 pub struct Builder {
343 pub(crate) upload_id: std::option::Option<std::string::String>,
344 pub(crate) presigned_request: std::option::Option<crate::model::UploadPresignedRequest>,
345 }
346 impl Builder {
347 pub fn upload_id(mut self, input: impl Into<std::string::String>) -> Self {
349 self.upload_id = Some(input.into());
350 self
351 }
352 pub fn set_upload_id(mut self, input: std::option::Option<std::string::String>) -> Self {
354 self.upload_id = input;
355 self
356 }
357 pub fn presigned_request(mut self, input: crate::model::UploadPresignedRequest) -> Self {
359 self.presigned_request = Some(input);
360 self
361 }
362 pub fn set_presigned_request(
364 mut self,
365 input: std::option::Option<crate::model::UploadPresignedRequest>,
366 ) -> Self {
367 self.presigned_request = input;
368 self
369 }
370 pub fn build(self) -> crate::output::PrepareGroupAvatarUploadOutput {
372 crate::output::PrepareGroupAvatarUploadOutput {
373 upload_id: self.upload_id,
374 presigned_request: self.presigned_request,
375 }
376 }
377 }
378}
379impl PrepareGroupAvatarUploadOutput {
380 pub fn builder() -> crate::output::prepare_group_avatar_upload_output::Builder {
382 crate::output::prepare_group_avatar_upload_output::Builder::default()
383 }
384}
385
386#[allow(missing_docs)] #[non_exhaustive]
388#[derive(std::clone::Clone, std::cmp::PartialEq)]
389pub struct SearchGroupsOutput {
390 pub groups: std::option::Option<std::vec::Vec<crate::model::GroupHandle>>,
392}
393impl SearchGroupsOutput {
394 pub fn groups(&self) -> std::option::Option<&[crate::model::GroupHandle]> {
396 self.groups.as_deref()
397 }
398}
399impl std::fmt::Debug for SearchGroupsOutput {
400 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 let mut formatter = f.debug_struct("SearchGroupsOutput");
402 formatter.field("groups", &self.groups);
403 formatter.finish()
404 }
405}
406pub mod search_groups_output {
408 #[non_exhaustive]
410 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
411 pub struct Builder {
412 pub(crate) groups: std::option::Option<std::vec::Vec<crate::model::GroupHandle>>,
413 }
414 impl Builder {
415 pub fn groups(mut self, input: crate::model::GroupHandle) -> Self {
421 let mut v = self.groups.unwrap_or_default();
422 v.push(input);
423 self.groups = Some(v);
424 self
425 }
426 pub fn set_groups(
428 mut self,
429 input: std::option::Option<std::vec::Vec<crate::model::GroupHandle>>,
430 ) -> Self {
431 self.groups = input;
432 self
433 }
434 pub fn build(self) -> crate::output::SearchGroupsOutput {
436 crate::output::SearchGroupsOutput {
437 groups: self.groups,
438 }
439 }
440 }
441}
442impl SearchGroupsOutput {
443 pub fn builder() -> crate::output::search_groups_output::Builder {
445 crate::output::search_groups_output::Builder::default()
446 }
447}
448
449#[allow(missing_docs)] #[non_exhaustive]
451#[derive(std::clone::Clone, std::cmp::PartialEq)]
452pub struct TransferGroupOwnershipOutput {}
453impl std::fmt::Debug for TransferGroupOwnershipOutput {
454 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
455 let mut formatter = f.debug_struct("TransferGroupOwnershipOutput");
456 formatter.finish()
457 }
458}
459pub mod transfer_group_ownership_output {
461 #[non_exhaustive]
463 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
464 pub struct Builder {}
465 impl Builder {
466 pub fn build(self) -> crate::output::TransferGroupOwnershipOutput {
468 crate::output::TransferGroupOwnershipOutput {}
469 }
470 }
471}
472impl TransferGroupOwnershipOutput {
473 pub fn builder() -> crate::output::transfer_group_ownership_output::Builder {
475 crate::output::transfer_group_ownership_output::Builder::default()
476 }
477}
478
479#[allow(missing_docs)] #[non_exhaustive]
481#[derive(std::clone::Clone, std::cmp::PartialEq)]
482pub struct ValidateGroupProfileOutput {
483 pub errors: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
485}
486impl ValidateGroupProfileOutput {
487 pub fn errors(&self) -> std::option::Option<&[crate::model::ValidationError]> {
489 self.errors.as_deref()
490 }
491}
492impl std::fmt::Debug for ValidateGroupProfileOutput {
493 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
494 let mut formatter = f.debug_struct("ValidateGroupProfileOutput");
495 formatter.field("errors", &self.errors);
496 formatter.finish()
497 }
498}
499pub mod validate_group_profile_output {
501 #[non_exhaustive]
503 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
504 pub struct Builder {
505 pub(crate) errors: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
506 }
507 impl Builder {
508 pub fn errors(mut self, input: crate::model::ValidationError) -> Self {
514 let mut v = self.errors.unwrap_or_default();
515 v.push(input);
516 self.errors = Some(v);
517 self
518 }
519 pub fn set_errors(
521 mut self,
522 input: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
523 ) -> Self {
524 self.errors = input;
525 self
526 }
527 pub fn build(self) -> crate::output::ValidateGroupProfileOutput {
529 crate::output::ValidateGroupProfileOutput {
530 errors: self.errors,
531 }
532 }
533 }
534}
535impl ValidateGroupProfileOutput {
536 pub fn builder() -> crate::output::validate_group_profile_output::Builder {
538 crate::output::validate_group_profile_output::Builder::default()
539 }
540}
541
542#[allow(missing_docs)] #[non_exhaustive]
544#[derive(std::clone::Clone, std::cmp::PartialEq)]
545pub struct GetGroupSummaryOutput {
546 pub group: std::option::Option<crate::model::GroupSummary>,
548}
549impl GetGroupSummaryOutput {
550 pub fn group(&self) -> std::option::Option<&crate::model::GroupSummary> {
552 self.group.as_ref()
553 }
554}
555impl std::fmt::Debug for GetGroupSummaryOutput {
556 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
557 let mut formatter = f.debug_struct("GetGroupSummaryOutput");
558 formatter.field("group", &self.group);
559 formatter.finish()
560 }
561}
562pub mod get_group_summary_output {
564 #[non_exhaustive]
566 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
567 pub struct Builder {
568 pub(crate) group: std::option::Option<crate::model::GroupSummary>,
569 }
570 impl Builder {
571 pub fn group(mut self, input: crate::model::GroupSummary) -> Self {
573 self.group = Some(input);
574 self
575 }
576 pub fn set_group(mut self, input: std::option::Option<crate::model::GroupSummary>) -> Self {
578 self.group = input;
579 self
580 }
581 pub fn build(self) -> crate::output::GetGroupSummaryOutput {
583 crate::output::GetGroupSummaryOutput { group: self.group }
584 }
585 }
586}
587impl GetGroupSummaryOutput {
588 pub fn builder() -> crate::output::get_group_summary_output::Builder {
590 crate::output::get_group_summary_output::Builder::default()
591 }
592}
593
594#[allow(missing_docs)] #[non_exhaustive]
596#[derive(std::clone::Clone, std::cmp::PartialEq)]
597pub struct UpdateGroupProfileOutput {}
598impl std::fmt::Debug for UpdateGroupProfileOutput {
599 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
600 let mut formatter = f.debug_struct("UpdateGroupProfileOutput");
601 formatter.finish()
602 }
603}
604pub mod update_group_profile_output {
606 #[non_exhaustive]
608 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
609 pub struct Builder {}
610 impl Builder {
611 pub fn build(self) -> crate::output::UpdateGroupProfileOutput {
613 crate::output::UpdateGroupProfileOutput {}
614 }
615 }
616}
617impl UpdateGroupProfileOutput {
618 pub fn builder() -> crate::output::update_group_profile_output::Builder {
620 crate::output::update_group_profile_output::Builder::default()
621 }
622}
623
624#[allow(missing_docs)] #[non_exhaustive]
626#[derive(std::clone::Clone, std::cmp::PartialEq)]
627pub struct GetGroupProfileOutput {
628 pub group: std::option::Option<crate::model::GroupProfile>,
630 pub watch: std::option::Option<crate::model::WatchResponse>,
632}
633impl GetGroupProfileOutput {
634 pub fn group(&self) -> std::option::Option<&crate::model::GroupProfile> {
636 self.group.as_ref()
637 }
638 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
640 self.watch.as_ref()
641 }
642}
643impl std::fmt::Debug for GetGroupProfileOutput {
644 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
645 let mut formatter = f.debug_struct("GetGroupProfileOutput");
646 formatter.field("group", &self.group);
647 formatter.field("watch", &self.watch);
648 formatter.finish()
649 }
650}
651pub mod get_group_profile_output {
653 #[non_exhaustive]
655 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
656 pub struct Builder {
657 pub(crate) group: std::option::Option<crate::model::GroupProfile>,
658 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
659 }
660 impl Builder {
661 pub fn group(mut self, input: crate::model::GroupProfile) -> Self {
663 self.group = Some(input);
664 self
665 }
666 pub fn set_group(mut self, input: std::option::Option<crate::model::GroupProfile>) -> Self {
668 self.group = input;
669 self
670 }
671 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
673 self.watch = Some(input);
674 self
675 }
676 pub fn set_watch(
678 mut self,
679 input: std::option::Option<crate::model::WatchResponse>,
680 ) -> Self {
681 self.watch = input;
682 self
683 }
684 pub fn build(self) -> crate::output::GetGroupProfileOutput {
686 crate::output::GetGroupProfileOutput {
687 group: self.group,
688 watch: self.watch,
689 }
690 }
691 }
692}
693impl GetGroupProfileOutput {
694 pub fn builder() -> crate::output::get_group_profile_output::Builder {
696 crate::output::get_group_profile_output::Builder::default()
697 }
698}
699
700#[allow(missing_docs)] #[non_exhaustive]
702#[derive(std::clone::Clone, std::cmp::PartialEq)]
703pub struct CreateGroupOutput {
704 pub group_id: std::option::Option<std::string::String>,
706}
707impl CreateGroupOutput {
708 pub fn group_id(&self) -> std::option::Option<&str> {
710 self.group_id.as_deref()
711 }
712}
713impl std::fmt::Debug for CreateGroupOutput {
714 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
715 let mut formatter = f.debug_struct("CreateGroupOutput");
716 formatter.field("group_id", &self.group_id);
717 formatter.finish()
718 }
719}
720pub mod create_group_output {
722 #[non_exhaustive]
724 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
725 pub struct Builder {
726 pub(crate) group_id: std::option::Option<std::string::String>,
727 }
728 impl Builder {
729 pub fn group_id(mut self, input: impl Into<std::string::String>) -> Self {
731 self.group_id = Some(input.into());
732 self
733 }
734 pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
736 self.group_id = input;
737 self
738 }
739 pub fn build(self) -> crate::output::CreateGroupOutput {
741 crate::output::CreateGroupOutput {
742 group_id: self.group_id,
743 }
744 }
745 }
746}
747impl CreateGroupOutput {
748 pub fn builder() -> crate::output::create_group_output::Builder {
750 crate::output::create_group_output::Builder::default()
751 }
752}
753
754#[allow(missing_docs)] #[non_exhaustive]
756#[derive(std::clone::Clone, std::cmp::PartialEq)]
757pub struct ListSuggestedGroupsOutput {
758 pub groups: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
760 pub watch: std::option::Option<crate::model::WatchResponse>,
762}
763impl ListSuggestedGroupsOutput {
764 pub fn groups(&self) -> std::option::Option<&[crate::model::GroupSummary]> {
766 self.groups.as_deref()
767 }
768 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
770 self.watch.as_ref()
771 }
772}
773impl std::fmt::Debug for ListSuggestedGroupsOutput {
774 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 let mut formatter = f.debug_struct("ListSuggestedGroupsOutput");
776 formatter.field("groups", &self.groups);
777 formatter.field("watch", &self.watch);
778 formatter.finish()
779 }
780}
781pub mod list_suggested_groups_output {
783 #[non_exhaustive]
785 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
786 pub struct Builder {
787 pub(crate) groups: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
788 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
789 }
790 impl Builder {
791 pub fn groups(mut self, input: crate::model::GroupSummary) -> Self {
797 let mut v = self.groups.unwrap_or_default();
798 v.push(input);
799 self.groups = Some(v);
800 self
801 }
802 pub fn set_groups(
804 mut self,
805 input: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
806 ) -> Self {
807 self.groups = input;
808 self
809 }
810 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
812 self.watch = Some(input);
813 self
814 }
815 pub fn set_watch(
817 mut self,
818 input: std::option::Option<crate::model::WatchResponse>,
819 ) -> Self {
820 self.watch = input;
821 self
822 }
823 pub fn build(self) -> crate::output::ListSuggestedGroupsOutput {
825 crate::output::ListSuggestedGroupsOutput {
826 groups: self.groups,
827 watch: self.watch,
828 }
829 }
830 }
831}
832impl ListSuggestedGroupsOutput {
833 pub fn builder() -> crate::output::list_suggested_groups_output::Builder {
835 crate::output::list_suggested_groups_output::Builder::default()
836 }
837}