1#[allow(missing_docs)] #[non_exhaustive]
4#[derive(std::clone::Clone, std::cmp::PartialEq)]
5pub struct ListActivitiesOutput {
6 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
8 pub games: std::option::Option<std::vec::Vec<crate::model::GameHandle>>,
10 pub parties: std::option::Option<std::vec::Vec<crate::model::PartySummary>>,
12 pub suggested_groups: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
14 pub suggested_players: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
16 pub watch: std::option::Option<crate::model::WatchResponse>,
18}
19impl ListActivitiesOutput {
20 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
22 self.identities.as_deref()
23 }
24 pub fn games(&self) -> std::option::Option<&[crate::model::GameHandle]> {
26 self.games.as_deref()
27 }
28 pub fn parties(&self) -> std::option::Option<&[crate::model::PartySummary]> {
30 self.parties.as_deref()
31 }
32 pub fn suggested_groups(&self) -> std::option::Option<&[crate::model::GroupSummary]> {
34 self.suggested_groups.as_deref()
35 }
36 pub fn suggested_players(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
38 self.suggested_players.as_deref()
39 }
40 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
42 self.watch.as_ref()
43 }
44}
45impl std::fmt::Debug for ListActivitiesOutput {
46 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 let mut formatter = f.debug_struct("ListActivitiesOutput");
48 formatter.field("identities", &self.identities);
49 formatter.field("games", &self.games);
50 formatter.field("parties", &self.parties);
51 formatter.field("suggested_groups", &self.suggested_groups);
52 formatter.field("suggested_players", &self.suggested_players);
53 formatter.field("watch", &self.watch);
54 formatter.finish()
55 }
56}
57pub mod list_activities_output {
59 #[non_exhaustive]
61 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
62 pub struct Builder {
63 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
64 pub(crate) games: std::option::Option<std::vec::Vec<crate::model::GameHandle>>,
65 pub(crate) parties: std::option::Option<std::vec::Vec<crate::model::PartySummary>>,
66 pub(crate) suggested_groups: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
67 pub(crate) suggested_players:
68 std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
69 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
70 }
71 impl Builder {
72 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
78 let mut v = self.identities.unwrap_or_default();
79 v.push(input);
80 self.identities = Some(v);
81 self
82 }
83 pub fn set_identities(
85 mut self,
86 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
87 ) -> Self {
88 self.identities = input;
89 self
90 }
91 pub fn games(mut self, input: crate::model::GameHandle) -> Self {
97 let mut v = self.games.unwrap_or_default();
98 v.push(input);
99 self.games = Some(v);
100 self
101 }
102 pub fn set_games(
104 mut self,
105 input: std::option::Option<std::vec::Vec<crate::model::GameHandle>>,
106 ) -> Self {
107 self.games = input;
108 self
109 }
110 pub fn parties(mut self, input: crate::model::PartySummary) -> Self {
116 let mut v = self.parties.unwrap_or_default();
117 v.push(input);
118 self.parties = Some(v);
119 self
120 }
121 pub fn set_parties(
123 mut self,
124 input: std::option::Option<std::vec::Vec<crate::model::PartySummary>>,
125 ) -> Self {
126 self.parties = input;
127 self
128 }
129 pub fn suggested_groups(mut self, input: crate::model::GroupSummary) -> Self {
135 let mut v = self.suggested_groups.unwrap_or_default();
136 v.push(input);
137 self.suggested_groups = Some(v);
138 self
139 }
140 pub fn set_suggested_groups(
142 mut self,
143 input: std::option::Option<std::vec::Vec<crate::model::GroupSummary>>,
144 ) -> Self {
145 self.suggested_groups = input;
146 self
147 }
148 pub fn suggested_players(mut self, input: crate::model::IdentityHandle) -> Self {
154 let mut v = self.suggested_players.unwrap_or_default();
155 v.push(input);
156 self.suggested_players = Some(v);
157 self
158 }
159 pub fn set_suggested_players(
161 mut self,
162 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
163 ) -> Self {
164 self.suggested_players = input;
165 self
166 }
167 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
169 self.watch = Some(input);
170 self
171 }
172 pub fn set_watch(
174 mut self,
175 input: std::option::Option<crate::model::WatchResponse>,
176 ) -> Self {
177 self.watch = input;
178 self
179 }
180 pub fn build(self) -> crate::output::ListActivitiesOutput {
182 crate::output::ListActivitiesOutput {
183 identities: self.identities,
184 games: self.games,
185 parties: self.parties,
186 suggested_groups: self.suggested_groups,
187 suggested_players: self.suggested_players,
188 watch: self.watch,
189 }
190 }
191 }
192}
193impl ListActivitiesOutput {
194 pub fn builder() -> crate::output::list_activities_output::Builder {
196 crate::output::list_activities_output::Builder::default()
197 }
198}
199
200#[allow(missing_docs)] #[non_exhaustive]
202#[derive(std::clone::Clone, std::cmp::PartialEq)]
203pub struct CancelGameLinkOutput {}
204impl std::fmt::Debug for CancelGameLinkOutput {
205 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
206 let mut formatter = f.debug_struct("CancelGameLinkOutput");
207 formatter.finish()
208 }
209}
210pub mod cancel_game_link_output {
212 #[non_exhaustive]
214 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
215 pub struct Builder {}
216 impl Builder {
217 pub fn build(self) -> crate::output::CancelGameLinkOutput {
219 crate::output::CancelGameLinkOutput {}
220 }
221 }
222}
223impl CancelGameLinkOutput {
224 pub fn builder() -> crate::output::cancel_game_link_output::Builder {
226 crate::output::cancel_game_link_output::Builder::default()
227 }
228}
229
230#[allow(missing_docs)] #[non_exhaustive]
232#[derive(std::clone::Clone, std::cmp::PartialEq)]
233pub struct CompleteGameLinkOutput {}
234impl std::fmt::Debug for CompleteGameLinkOutput {
235 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
236 let mut formatter = f.debug_struct("CompleteGameLinkOutput");
237 formatter.finish()
238 }
239}
240pub mod complete_game_link_output {
242 #[non_exhaustive]
244 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
245 pub struct Builder {}
246 impl Builder {
247 pub fn build(self) -> crate::output::CompleteGameLinkOutput {
249 crate::output::CompleteGameLinkOutput {}
250 }
251 }
252}
253impl CompleteGameLinkOutput {
254 pub fn builder() -> crate::output::complete_game_link_output::Builder {
256 crate::output::complete_game_link_output::Builder::default()
257 }
258}
259
260#[allow(missing_docs)] #[non_exhaustive]
262#[derive(std::clone::Clone, std::cmp::PartialEq)]
263pub struct GetGameLinkOutput {
264 pub status: std::option::Option<crate::model::GameLinkStatus>,
266 pub game: std::option::Option<crate::model::GameHandle>,
268 pub current_identity: std::option::Option<crate::model::IdentityHandle>,
270 pub new_identity: std::option::Option<crate::model::GetGameLinkNewIdentity>,
272 pub watch: std::option::Option<crate::model::WatchResponse>,
274}
275impl GetGameLinkOutput {
276 pub fn status(&self) -> std::option::Option<&crate::model::GameLinkStatus> {
278 self.status.as_ref()
279 }
280 pub fn game(&self) -> std::option::Option<&crate::model::GameHandle> {
282 self.game.as_ref()
283 }
284 pub fn current_identity(&self) -> std::option::Option<&crate::model::IdentityHandle> {
286 self.current_identity.as_ref()
287 }
288 pub fn new_identity(&self) -> std::option::Option<&crate::model::GetGameLinkNewIdentity> {
290 self.new_identity.as_ref()
291 }
292 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
294 self.watch.as_ref()
295 }
296}
297impl std::fmt::Debug for GetGameLinkOutput {
298 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
299 let mut formatter = f.debug_struct("GetGameLinkOutput");
300 formatter.field("status", &self.status);
301 formatter.field("game", &self.game);
302 formatter.field("current_identity", &self.current_identity);
303 formatter.field("new_identity", &self.new_identity);
304 formatter.field("watch", &self.watch);
305 formatter.finish()
306 }
307}
308pub mod get_game_link_output {
310 #[non_exhaustive]
312 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
313 pub struct Builder {
314 pub(crate) status: std::option::Option<crate::model::GameLinkStatus>,
315 pub(crate) game: std::option::Option<crate::model::GameHandle>,
316 pub(crate) current_identity: std::option::Option<crate::model::IdentityHandle>,
317 pub(crate) new_identity: std::option::Option<crate::model::GetGameLinkNewIdentity>,
318 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
319 }
320 impl Builder {
321 pub fn status(mut self, input: crate::model::GameLinkStatus) -> Self {
323 self.status = Some(input);
324 self
325 }
326 pub fn set_status(
328 mut self,
329 input: std::option::Option<crate::model::GameLinkStatus>,
330 ) -> Self {
331 self.status = input;
332 self
333 }
334 pub fn game(mut self, input: crate::model::GameHandle) -> Self {
336 self.game = Some(input);
337 self
338 }
339 pub fn set_game(mut self, input: std::option::Option<crate::model::GameHandle>) -> Self {
341 self.game = input;
342 self
343 }
344 pub fn current_identity(mut self, input: crate::model::IdentityHandle) -> Self {
346 self.current_identity = Some(input);
347 self
348 }
349 pub fn set_current_identity(
351 mut self,
352 input: std::option::Option<crate::model::IdentityHandle>,
353 ) -> Self {
354 self.current_identity = input;
355 self
356 }
357 pub fn new_identity(mut self, input: crate::model::GetGameLinkNewIdentity) -> Self {
359 self.new_identity = Some(input);
360 self
361 }
362 pub fn set_new_identity(
364 mut self,
365 input: std::option::Option<crate::model::GetGameLinkNewIdentity>,
366 ) -> Self {
367 self.new_identity = input;
368 self
369 }
370 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
372 self.watch = Some(input);
373 self
374 }
375 pub fn set_watch(
377 mut self,
378 input: std::option::Option<crate::model::WatchResponse>,
379 ) -> Self {
380 self.watch = input;
381 self
382 }
383 pub fn build(self) -> crate::output::GetGameLinkOutput {
385 crate::output::GetGameLinkOutput {
386 status: self.status,
387 game: self.game,
388 current_identity: self.current_identity,
389 new_identity: self.new_identity,
390 watch: self.watch,
391 }
392 }
393 }
394}
395impl GetGameLinkOutput {
396 pub fn builder() -> crate::output::get_game_link_output::Builder {
398 crate::output::get_game_link_output::Builder::default()
399 }
400}
401
402#[allow(missing_docs)] #[non_exhaustive]
404#[derive(std::clone::Clone, std::cmp::PartialEq)]
405pub struct PrepareGameLinkOutput {
406 pub identity_link_token: std::option::Option<std::string::String>,
408 pub identity_link_url: std::option::Option<std::string::String>,
410 pub expire_ts: std::option::Option<aws_smithy_types::DateTime>,
412}
413impl PrepareGameLinkOutput {
414 pub fn identity_link_token(&self) -> std::option::Option<&str> {
416 self.identity_link_token.as_deref()
417 }
418 pub fn identity_link_url(&self) -> std::option::Option<&str> {
420 self.identity_link_url.as_deref()
421 }
422 pub fn expire_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
424 self.expire_ts.as_ref()
425 }
426}
427impl std::fmt::Debug for PrepareGameLinkOutput {
428 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
429 let mut formatter = f.debug_struct("PrepareGameLinkOutput");
430 formatter.field("identity_link_token", &self.identity_link_token);
431 formatter.field("identity_link_url", &self.identity_link_url);
432 formatter.field("expire_ts", &self.expire_ts);
433 formatter.finish()
434 }
435}
436pub mod prepare_game_link_output {
438 #[non_exhaustive]
440 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
441 pub struct Builder {
442 pub(crate) identity_link_token: std::option::Option<std::string::String>,
443 pub(crate) identity_link_url: std::option::Option<std::string::String>,
444 pub(crate) expire_ts: std::option::Option<aws_smithy_types::DateTime>,
445 }
446 impl Builder {
447 pub fn identity_link_token(mut self, input: impl Into<std::string::String>) -> Self {
449 self.identity_link_token = Some(input.into());
450 self
451 }
452 pub fn set_identity_link_token(
454 mut self,
455 input: std::option::Option<std::string::String>,
456 ) -> Self {
457 self.identity_link_token = input;
458 self
459 }
460 pub fn identity_link_url(mut self, input: impl Into<std::string::String>) -> Self {
462 self.identity_link_url = Some(input.into());
463 self
464 }
465 pub fn set_identity_link_url(
467 mut self,
468 input: std::option::Option<std::string::String>,
469 ) -> Self {
470 self.identity_link_url = input;
471 self
472 }
473 pub fn expire_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
475 self.expire_ts = Some(input);
476 self
477 }
478 pub fn set_expire_ts(
480 mut self,
481 input: std::option::Option<aws_smithy_types::DateTime>,
482 ) -> Self {
483 self.expire_ts = input;
484 self
485 }
486 pub fn build(self) -> crate::output::PrepareGameLinkOutput {
488 crate::output::PrepareGameLinkOutput {
489 identity_link_token: self.identity_link_token,
490 identity_link_url: self.identity_link_url,
491 expire_ts: self.expire_ts,
492 }
493 }
494 }
495}
496impl PrepareGameLinkOutput {
497 pub fn builder() -> crate::output::prepare_game_link_output::Builder {
499 crate::output::prepare_game_link_output::Builder::default()
500 }
501}
502
503#[allow(missing_docs)] #[non_exhaustive]
505#[derive(std::clone::Clone, std::cmp::PartialEq)]
506pub struct WatchEventsOutput {
507 pub events: std::option::Option<std::vec::Vec<crate::model::GlobalEvent>>,
509 pub watch: std::option::Option<crate::model::WatchResponse>,
511}
512impl WatchEventsOutput {
513 pub fn events(&self) -> std::option::Option<&[crate::model::GlobalEvent]> {
515 self.events.as_deref()
516 }
517 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
519 self.watch.as_ref()
520 }
521}
522impl std::fmt::Debug for WatchEventsOutput {
523 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
524 let mut formatter = f.debug_struct("WatchEventsOutput");
525 formatter.field("events", &self.events);
526 formatter.field("watch", &self.watch);
527 formatter.finish()
528 }
529}
530pub mod watch_events_output {
532 #[non_exhaustive]
534 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
535 pub struct Builder {
536 pub(crate) events: std::option::Option<std::vec::Vec<crate::model::GlobalEvent>>,
537 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
538 }
539 impl Builder {
540 pub fn events(mut self, input: crate::model::GlobalEvent) -> Self {
546 let mut v = self.events.unwrap_or_default();
547 v.push(input);
548 self.events = Some(v);
549 self
550 }
551 pub fn set_events(
553 mut self,
554 input: std::option::Option<std::vec::Vec<crate::model::GlobalEvent>>,
555 ) -> Self {
556 self.events = input;
557 self
558 }
559 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
561 self.watch = Some(input);
562 self
563 }
564 pub fn set_watch(
566 mut self,
567 input: std::option::Option<crate::model::WatchResponse>,
568 ) -> Self {
569 self.watch = input;
570 self
571 }
572 pub fn build(self) -> crate::output::WatchEventsOutput {
574 crate::output::WatchEventsOutput {
575 events: self.events,
576 watch: self.watch,
577 }
578 }
579 }
580}
581impl WatchEventsOutput {
582 pub fn builder() -> crate::output::watch_events_output::Builder {
584 crate::output::watch_events_output::Builder::default()
585 }
586}
587
588#[allow(missing_docs)] #[non_exhaustive]
590#[derive(std::clone::Clone, std::cmp::PartialEq)]
591pub struct ListMutualFriendsOutput {
592 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
594 #[allow(missing_docs)] pub anchor: std::option::Option<std::string::String>,
596}
597impl ListMutualFriendsOutput {
598 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
600 self.identities.as_deref()
601 }
602 #[allow(missing_docs)] pub fn anchor(&self) -> std::option::Option<&str> {
604 self.anchor.as_deref()
605 }
606}
607impl std::fmt::Debug for ListMutualFriendsOutput {
608 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
609 let mut formatter = f.debug_struct("ListMutualFriendsOutput");
610 formatter.field("identities", &self.identities);
611 formatter.field("anchor", &self.anchor);
612 formatter.finish()
613 }
614}
615pub mod list_mutual_friends_output {
617 #[non_exhaustive]
619 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
620 pub struct Builder {
621 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
622 pub(crate) anchor: std::option::Option<std::string::String>,
623 }
624 impl Builder {
625 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
631 let mut v = self.identities.unwrap_or_default();
632 v.push(input);
633 self.identities = Some(v);
634 self
635 }
636 pub fn set_identities(
638 mut self,
639 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
640 ) -> Self {
641 self.identities = input;
642 self
643 }
644 #[allow(missing_docs)] pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
646 self.anchor = Some(input.into());
647 self
648 }
649 #[allow(missing_docs)] pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
651 self.anchor = input;
652 self
653 }
654 pub fn build(self) -> crate::output::ListMutualFriendsOutput {
656 crate::output::ListMutualFriendsOutput {
657 identities: self.identities,
658 anchor: self.anchor,
659 }
660 }
661 }
662}
663impl ListMutualFriendsOutput {
664 pub fn builder() -> crate::output::list_mutual_friends_output::Builder {
666 crate::output::list_mutual_friends_output::Builder::default()
667 }
668}
669
670#[allow(missing_docs)] #[non_exhaustive]
672#[derive(std::clone::Clone, std::cmp::PartialEq)]
673pub struct GetIdentitySummariesOutput {
674 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentitySummary>>,
676}
677impl GetIdentitySummariesOutput {
678 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentitySummary]> {
680 self.identities.as_deref()
681 }
682}
683impl std::fmt::Debug for GetIdentitySummariesOutput {
684 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
685 let mut formatter = f.debug_struct("GetIdentitySummariesOutput");
686 formatter.field("identities", &self.identities);
687 formatter.finish()
688 }
689}
690pub mod get_identity_summaries_output {
692 #[non_exhaustive]
694 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
695 pub struct Builder {
696 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentitySummary>>,
697 }
698 impl Builder {
699 pub fn identities(mut self, input: crate::model::IdentitySummary) -> Self {
705 let mut v = self.identities.unwrap_or_default();
706 v.push(input);
707 self.identities = Some(v);
708 self
709 }
710 pub fn set_identities(
712 mut self,
713 input: std::option::Option<std::vec::Vec<crate::model::IdentitySummary>>,
714 ) -> Self {
715 self.identities = input;
716 self
717 }
718 pub fn build(self) -> crate::output::GetIdentitySummariesOutput {
720 crate::output::GetIdentitySummariesOutput {
721 identities: self.identities,
722 }
723 }
724 }
725}
726impl GetIdentitySummariesOutput {
727 pub fn builder() -> crate::output::get_identity_summaries_output::Builder {
729 crate::output::get_identity_summaries_output::Builder::default()
730 }
731}
732
733#[allow(missing_docs)] #[non_exhaustive]
735#[derive(std::clone::Clone, std::cmp::PartialEq)]
736pub struct GetIdentityHandlesOutput {
737 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
739}
740impl GetIdentityHandlesOutput {
741 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
743 self.identities.as_deref()
744 }
745}
746impl std::fmt::Debug for GetIdentityHandlesOutput {
747 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
748 let mut formatter = f.debug_struct("GetIdentityHandlesOutput");
749 formatter.field("identities", &self.identities);
750 formatter.finish()
751 }
752}
753pub mod get_identity_handles_output {
755 #[non_exhaustive]
757 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
758 pub struct Builder {
759 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
760 }
761 impl Builder {
762 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
768 let mut v = self.identities.unwrap_or_default();
769 v.push(input);
770 self.identities = Some(v);
771 self
772 }
773 pub fn set_identities(
775 mut self,
776 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
777 ) -> Self {
778 self.identities = input;
779 self
780 }
781 pub fn build(self) -> crate::output::GetIdentityHandlesOutput {
783 crate::output::GetIdentityHandlesOutput {
784 identities: self.identities,
785 }
786 }
787 }
788}
789impl GetIdentityHandlesOutput {
790 pub fn builder() -> crate::output::get_identity_handles_output::Builder {
792 crate::output::get_identity_handles_output::Builder::default()
793 }
794}
795
796#[allow(missing_docs)] #[non_exhaustive]
798#[derive(std::clone::Clone, std::cmp::PartialEq)]
799pub struct ReportIdentityOutput {}
800impl std::fmt::Debug for ReportIdentityOutput {
801 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
802 let mut formatter = f.debug_struct("ReportIdentityOutput");
803 formatter.finish()
804 }
805}
806pub mod report_identity_output {
808 #[non_exhaustive]
810 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
811 pub struct Builder {}
812 impl Builder {
813 pub fn build(self) -> crate::output::ReportIdentityOutput {
815 crate::output::ReportIdentityOutput {}
816 }
817 }
818}
819impl ReportIdentityOutput {
820 pub fn builder() -> crate::output::report_identity_output::Builder {
822 crate::output::report_identity_output::Builder::default()
823 }
824}
825
826#[allow(missing_docs)] #[non_exhaustive]
828#[derive(std::clone::Clone, std::cmp::PartialEq)]
829pub struct ListFriendsOutput {
830 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
832 #[allow(missing_docs)] pub anchor: std::option::Option<std::string::String>,
834}
835impl ListFriendsOutput {
836 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
838 self.identities.as_deref()
839 }
840 #[allow(missing_docs)] pub fn anchor(&self) -> std::option::Option<&str> {
842 self.anchor.as_deref()
843 }
844}
845impl std::fmt::Debug for ListFriendsOutput {
846 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
847 let mut formatter = f.debug_struct("ListFriendsOutput");
848 formatter.field("identities", &self.identities);
849 formatter.field("anchor", &self.anchor);
850 formatter.finish()
851 }
852}
853pub mod list_friends_output {
855 #[non_exhaustive]
857 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
858 pub struct Builder {
859 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
860 pub(crate) anchor: std::option::Option<std::string::String>,
861 }
862 impl Builder {
863 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
869 let mut v = self.identities.unwrap_or_default();
870 v.push(input);
871 self.identities = Some(v);
872 self
873 }
874 pub fn set_identities(
876 mut self,
877 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
878 ) -> Self {
879 self.identities = input;
880 self
881 }
882 #[allow(missing_docs)] pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
884 self.anchor = Some(input.into());
885 self
886 }
887 #[allow(missing_docs)] pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
889 self.anchor = input;
890 self
891 }
892 pub fn build(self) -> crate::output::ListFriendsOutput {
894 crate::output::ListFriendsOutput {
895 identities: self.identities,
896 anchor: self.anchor,
897 }
898 }
899 }
900}
901impl ListFriendsOutput {
902 pub fn builder() -> crate::output::list_friends_output::Builder {
904 crate::output::list_friends_output::Builder::default()
905 }
906}
907
908#[allow(missing_docs)] #[non_exhaustive]
910#[derive(std::clone::Clone, std::cmp::PartialEq)]
911pub struct ListFollowingOutput {
912 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
914 #[allow(missing_docs)] pub anchor: std::option::Option<std::string::String>,
916}
917impl ListFollowingOutput {
918 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
920 self.identities.as_deref()
921 }
922 #[allow(missing_docs)] pub fn anchor(&self) -> std::option::Option<&str> {
924 self.anchor.as_deref()
925 }
926}
927impl std::fmt::Debug for ListFollowingOutput {
928 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
929 let mut formatter = f.debug_struct("ListFollowingOutput");
930 formatter.field("identities", &self.identities);
931 formatter.field("anchor", &self.anchor);
932 formatter.finish()
933 }
934}
935pub mod list_following_output {
937 #[non_exhaustive]
939 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
940 pub struct Builder {
941 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
942 pub(crate) anchor: std::option::Option<std::string::String>,
943 }
944 impl Builder {
945 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
951 let mut v = self.identities.unwrap_or_default();
952 v.push(input);
953 self.identities = Some(v);
954 self
955 }
956 pub fn set_identities(
958 mut self,
959 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
960 ) -> Self {
961 self.identities = input;
962 self
963 }
964 #[allow(missing_docs)] pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
966 self.anchor = Some(input.into());
967 self
968 }
969 #[allow(missing_docs)] pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
971 self.anchor = input;
972 self
973 }
974 pub fn build(self) -> crate::output::ListFollowingOutput {
976 crate::output::ListFollowingOutput {
977 identities: self.identities,
978 anchor: self.anchor,
979 }
980 }
981 }
982}
983impl ListFollowingOutput {
984 pub fn builder() -> crate::output::list_following_output::Builder {
986 crate::output::list_following_output::Builder::default()
987 }
988}
989
990#[allow(missing_docs)] #[non_exhaustive]
992#[derive(std::clone::Clone, std::cmp::PartialEq)]
993pub struct ListFollowersOutput {
994 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
996 #[allow(missing_docs)] pub anchor: std::option::Option<std::string::String>,
998}
999impl ListFollowersOutput {
1000 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
1002 self.identities.as_deref()
1003 }
1004 #[allow(missing_docs)] pub fn anchor(&self) -> std::option::Option<&str> {
1006 self.anchor.as_deref()
1007 }
1008}
1009impl std::fmt::Debug for ListFollowersOutput {
1010 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1011 let mut formatter = f.debug_struct("ListFollowersOutput");
1012 formatter.field("identities", &self.identities);
1013 formatter.field("anchor", &self.anchor);
1014 formatter.finish()
1015 }
1016}
1017pub mod list_followers_output {
1019 #[non_exhaustive]
1021 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1022 pub struct Builder {
1023 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
1024 pub(crate) anchor: std::option::Option<std::string::String>,
1025 }
1026 impl Builder {
1027 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
1033 let mut v = self.identities.unwrap_or_default();
1034 v.push(input);
1035 self.identities = Some(v);
1036 self
1037 }
1038 pub fn set_identities(
1040 mut self,
1041 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
1042 ) -> Self {
1043 self.identities = input;
1044 self
1045 }
1046 #[allow(missing_docs)] pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1048 self.anchor = Some(input.into());
1049 self
1050 }
1051 #[allow(missing_docs)] pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1053 self.anchor = input;
1054 self
1055 }
1056 pub fn build(self) -> crate::output::ListFollowersOutput {
1058 crate::output::ListFollowersOutput {
1059 identities: self.identities,
1060 anchor: self.anchor,
1061 }
1062 }
1063 }
1064}
1065impl ListFollowersOutput {
1066 pub fn builder() -> crate::output::list_followers_output::Builder {
1068 crate::output::list_followers_output::Builder::default()
1069 }
1070}
1071
1072#[allow(missing_docs)] #[non_exhaustive]
1074#[derive(std::clone::Clone, std::cmp::PartialEq)]
1075pub struct SignupForBetaOutput {}
1076impl std::fmt::Debug for SignupForBetaOutput {
1077 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1078 let mut formatter = f.debug_struct("SignupForBetaOutput");
1079 formatter.finish()
1080 }
1081}
1082pub mod signup_for_beta_output {
1084 #[non_exhaustive]
1086 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1087 pub struct Builder {}
1088 impl Builder {
1089 pub fn build(self) -> crate::output::SignupForBetaOutput {
1091 crate::output::SignupForBetaOutput {}
1092 }
1093 }
1094}
1095impl SignupForBetaOutput {
1096 pub fn builder() -> crate::output::signup_for_beta_output::Builder {
1098 crate::output::signup_for_beta_output::Builder::default()
1099 }
1100}
1101
1102#[allow(missing_docs)] #[non_exhaustive]
1104#[derive(std::clone::Clone, std::cmp::PartialEq)]
1105pub struct CompleteIdentityAvatarUploadOutput {}
1106impl std::fmt::Debug for CompleteIdentityAvatarUploadOutput {
1107 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1108 let mut formatter = f.debug_struct("CompleteIdentityAvatarUploadOutput");
1109 formatter.finish()
1110 }
1111}
1112pub mod complete_identity_avatar_upload_output {
1114 #[non_exhaustive]
1116 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1117 pub struct Builder {}
1118 impl Builder {
1119 pub fn build(self) -> crate::output::CompleteIdentityAvatarUploadOutput {
1121 crate::output::CompleteIdentityAvatarUploadOutput {}
1122 }
1123 }
1124}
1125impl CompleteIdentityAvatarUploadOutput {
1126 pub fn builder() -> crate::output::complete_identity_avatar_upload_output::Builder {
1128 crate::output::complete_identity_avatar_upload_output::Builder::default()
1129 }
1130}
1131
1132#[allow(missing_docs)] #[non_exhaustive]
1134#[derive(std::clone::Clone, std::cmp::PartialEq)]
1135pub struct PrepareIdentityAvatarUploadOutput {
1136 pub upload_id: std::option::Option<std::string::String>,
1138 pub presigned_request: std::option::Option<crate::model::UploadPresignedRequest>,
1140}
1141impl PrepareIdentityAvatarUploadOutput {
1142 pub fn upload_id(&self) -> std::option::Option<&str> {
1144 self.upload_id.as_deref()
1145 }
1146 pub fn presigned_request(&self) -> std::option::Option<&crate::model::UploadPresignedRequest> {
1148 self.presigned_request.as_ref()
1149 }
1150}
1151impl std::fmt::Debug for PrepareIdentityAvatarUploadOutput {
1152 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1153 let mut formatter = f.debug_struct("PrepareIdentityAvatarUploadOutput");
1154 formatter.field("upload_id", &self.upload_id);
1155 formatter.field("presigned_request", &self.presigned_request);
1156 formatter.finish()
1157 }
1158}
1159pub mod prepare_identity_avatar_upload_output {
1161 #[non_exhaustive]
1163 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1164 pub struct Builder {
1165 pub(crate) upload_id: std::option::Option<std::string::String>,
1166 pub(crate) presigned_request: std::option::Option<crate::model::UploadPresignedRequest>,
1167 }
1168 impl Builder {
1169 pub fn upload_id(mut self, input: impl Into<std::string::String>) -> Self {
1171 self.upload_id = Some(input.into());
1172 self
1173 }
1174 pub fn set_upload_id(mut self, input: std::option::Option<std::string::String>) -> Self {
1176 self.upload_id = input;
1177 self
1178 }
1179 pub fn presigned_request(mut self, input: crate::model::UploadPresignedRequest) -> Self {
1181 self.presigned_request = Some(input);
1182 self
1183 }
1184 pub fn set_presigned_request(
1186 mut self,
1187 input: std::option::Option<crate::model::UploadPresignedRequest>,
1188 ) -> Self {
1189 self.presigned_request = input;
1190 self
1191 }
1192 pub fn build(self) -> crate::output::PrepareIdentityAvatarUploadOutput {
1194 crate::output::PrepareIdentityAvatarUploadOutput {
1195 upload_id: self.upload_id,
1196 presigned_request: self.presigned_request,
1197 }
1198 }
1199 }
1200}
1201impl PrepareIdentityAvatarUploadOutput {
1202 pub fn builder() -> crate::output::prepare_identity_avatar_upload_output::Builder {
1204 crate::output::prepare_identity_avatar_upload_output::Builder::default()
1205 }
1206}
1207
1208#[allow(missing_docs)] #[non_exhaustive]
1210#[derive(std::clone::Clone, std::cmp::PartialEq)]
1211pub struct UnfollowIdentityOutput {}
1212impl std::fmt::Debug for UnfollowIdentityOutput {
1213 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1214 let mut formatter = f.debug_struct("UnfollowIdentityOutput");
1215 formatter.finish()
1216 }
1217}
1218pub mod unfollow_identity_output {
1220 #[non_exhaustive]
1222 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1223 pub struct Builder {}
1224 impl Builder {
1225 pub fn build(self) -> crate::output::UnfollowIdentityOutput {
1227 crate::output::UnfollowIdentityOutput {}
1228 }
1229 }
1230}
1231impl UnfollowIdentityOutput {
1232 pub fn builder() -> crate::output::unfollow_identity_output::Builder {
1234 crate::output::unfollow_identity_output::Builder::default()
1235 }
1236}
1237
1238#[allow(missing_docs)] #[non_exhaustive]
1240#[derive(std::clone::Clone, std::cmp::PartialEq)]
1241pub struct FollowIdentityOutput {}
1242impl std::fmt::Debug for FollowIdentityOutput {
1243 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1244 let mut formatter = f.debug_struct("FollowIdentityOutput");
1245 formatter.finish()
1246 }
1247}
1248pub mod follow_identity_output {
1250 #[non_exhaustive]
1252 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1253 pub struct Builder {}
1254 impl Builder {
1255 pub fn build(self) -> crate::output::FollowIdentityOutput {
1257 crate::output::FollowIdentityOutput {}
1258 }
1259 }
1260}
1261impl FollowIdentityOutput {
1262 pub fn builder() -> crate::output::follow_identity_output::Builder {
1264 crate::output::follow_identity_output::Builder::default()
1265 }
1266}
1267
1268#[allow(missing_docs)] #[non_exhaustive]
1270#[derive(std::clone::Clone, std::cmp::PartialEq)]
1271pub struct UpdateIdentityStatusOutput {}
1272impl std::fmt::Debug for UpdateIdentityStatusOutput {
1273 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274 let mut formatter = f.debug_struct("UpdateIdentityStatusOutput");
1275 formatter.finish()
1276 }
1277}
1278pub mod update_identity_status_output {
1280 #[non_exhaustive]
1282 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1283 pub struct Builder {}
1284 impl Builder {
1285 pub fn build(self) -> crate::output::UpdateIdentityStatusOutput {
1287 crate::output::UpdateIdentityStatusOutput {}
1288 }
1289 }
1290}
1291impl UpdateIdentityStatusOutput {
1292 pub fn builder() -> crate::output::update_identity_status_output::Builder {
1294 crate::output::update_identity_status_output::Builder::default()
1295 }
1296}
1297
1298#[allow(missing_docs)] #[non_exhaustive]
1300#[derive(std::clone::Clone, std::cmp::PartialEq)]
1301pub struct RemoveIdentityGameActivityOutput {}
1302impl std::fmt::Debug for RemoveIdentityGameActivityOutput {
1303 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1304 let mut formatter = f.debug_struct("RemoveIdentityGameActivityOutput");
1305 formatter.finish()
1306 }
1307}
1308pub mod remove_identity_game_activity_output {
1310 #[non_exhaustive]
1312 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1313 pub struct Builder {}
1314 impl Builder {
1315 pub fn build(self) -> crate::output::RemoveIdentityGameActivityOutput {
1317 crate::output::RemoveIdentityGameActivityOutput {}
1318 }
1319 }
1320}
1321impl RemoveIdentityGameActivityOutput {
1322 pub fn builder() -> crate::output::remove_identity_game_activity_output::Builder {
1324 crate::output::remove_identity_game_activity_output::Builder::default()
1325 }
1326}
1327
1328#[allow(missing_docs)] #[non_exhaustive]
1330#[derive(std::clone::Clone, std::cmp::PartialEq)]
1331pub struct SetIdentityGameActivityOutput {}
1332impl std::fmt::Debug for SetIdentityGameActivityOutput {
1333 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1334 let mut formatter = f.debug_struct("SetIdentityGameActivityOutput");
1335 formatter.finish()
1336 }
1337}
1338pub mod set_identity_game_activity_output {
1340 #[non_exhaustive]
1342 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1343 pub struct Builder {}
1344 impl Builder {
1345 pub fn build(self) -> crate::output::SetIdentityGameActivityOutput {
1347 crate::output::SetIdentityGameActivityOutput {}
1348 }
1349 }
1350}
1351impl SetIdentityGameActivityOutput {
1352 pub fn builder() -> crate::output::set_identity_game_activity_output::Builder {
1354 crate::output::set_identity_game_activity_output::Builder::default()
1355 }
1356}
1357
1358#[allow(missing_docs)] #[non_exhaustive]
1360#[derive(std::clone::Clone, std::cmp::PartialEq)]
1361pub struct SearchIdentitiesOutput {
1362 pub identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
1364 pub anchor: std::option::Option<std::string::String>,
1366}
1367impl SearchIdentitiesOutput {
1368 pub fn identities(&self) -> std::option::Option<&[crate::model::IdentityHandle]> {
1370 self.identities.as_deref()
1371 }
1372 pub fn anchor(&self) -> std::option::Option<&str> {
1374 self.anchor.as_deref()
1375 }
1376}
1377impl std::fmt::Debug for SearchIdentitiesOutput {
1378 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1379 let mut formatter = f.debug_struct("SearchIdentitiesOutput");
1380 formatter.field("identities", &self.identities);
1381 formatter.field("anchor", &self.anchor);
1382 formatter.finish()
1383 }
1384}
1385pub mod search_identities_output {
1387 #[non_exhaustive]
1389 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1390 pub struct Builder {
1391 pub(crate) identities: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
1392 pub(crate) anchor: std::option::Option<std::string::String>,
1393 }
1394 impl Builder {
1395 pub fn identities(mut self, input: crate::model::IdentityHandle) -> Self {
1401 let mut v = self.identities.unwrap_or_default();
1402 v.push(input);
1403 self.identities = Some(v);
1404 self
1405 }
1406 pub fn set_identities(
1408 mut self,
1409 input: std::option::Option<std::vec::Vec<crate::model::IdentityHandle>>,
1410 ) -> Self {
1411 self.identities = input;
1412 self
1413 }
1414 pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1416 self.anchor = Some(input.into());
1417 self
1418 }
1419 pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1421 self.anchor = input;
1422 self
1423 }
1424 pub fn build(self) -> crate::output::SearchIdentitiesOutput {
1426 crate::output::SearchIdentitiesOutput {
1427 identities: self.identities,
1428 anchor: self.anchor,
1429 }
1430 }
1431 }
1432}
1433impl SearchIdentitiesOutput {
1434 pub fn builder() -> crate::output::search_identities_output::Builder {
1436 crate::output::search_identities_output::Builder::default()
1437 }
1438}
1439
1440#[allow(missing_docs)] #[non_exhaustive]
1442#[derive(std::clone::Clone, std::cmp::PartialEq)]
1443pub struct ValidateIdentityProfileOutput {
1444 pub errors: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
1446}
1447impl ValidateIdentityProfileOutput {
1448 pub fn errors(&self) -> std::option::Option<&[crate::model::ValidationError]> {
1450 self.errors.as_deref()
1451 }
1452}
1453impl std::fmt::Debug for ValidateIdentityProfileOutput {
1454 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1455 let mut formatter = f.debug_struct("ValidateIdentityProfileOutput");
1456 formatter.field("errors", &self.errors);
1457 formatter.finish()
1458 }
1459}
1460pub mod validate_identity_profile_output {
1462 #[non_exhaustive]
1464 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1465 pub struct Builder {
1466 pub(crate) errors: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
1467 }
1468 impl Builder {
1469 pub fn errors(mut self, input: crate::model::ValidationError) -> Self {
1475 let mut v = self.errors.unwrap_or_default();
1476 v.push(input);
1477 self.errors = Some(v);
1478 self
1479 }
1480 pub fn set_errors(
1482 mut self,
1483 input: std::option::Option<std::vec::Vec<crate::model::ValidationError>>,
1484 ) -> Self {
1485 self.errors = input;
1486 self
1487 }
1488 pub fn build(self) -> crate::output::ValidateIdentityProfileOutput {
1490 crate::output::ValidateIdentityProfileOutput {
1491 errors: self.errors,
1492 }
1493 }
1494 }
1495}
1496impl ValidateIdentityProfileOutput {
1497 pub fn builder() -> crate::output::validate_identity_profile_output::Builder {
1499 crate::output::validate_identity_profile_output::Builder::default()
1500 }
1501}
1502
1503#[allow(missing_docs)] #[non_exhaustive]
1505#[derive(std::clone::Clone, std::cmp::PartialEq)]
1506pub struct UpdateIdentityProfileOutput {}
1507impl std::fmt::Debug for UpdateIdentityProfileOutput {
1508 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1509 let mut formatter = f.debug_struct("UpdateIdentityProfileOutput");
1510 formatter.finish()
1511 }
1512}
1513pub mod update_identity_profile_output {
1515 #[non_exhaustive]
1517 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1518 pub struct Builder {}
1519 impl Builder {
1520 pub fn build(self) -> crate::output::UpdateIdentityProfileOutput {
1522 crate::output::UpdateIdentityProfileOutput {}
1523 }
1524 }
1525}
1526impl UpdateIdentityProfileOutput {
1527 pub fn builder() -> crate::output::update_identity_profile_output::Builder {
1529 crate::output::update_identity_profile_output::Builder::default()
1530 }
1531}
1532
1533#[allow(missing_docs)] #[non_exhaustive]
1535#[derive(std::clone::Clone, std::cmp::PartialEq)]
1536pub struct GetIdentitySelfProfileOutput {
1537 pub identity: std::option::Option<crate::model::IdentityProfile>,
1539 pub watch: std::option::Option<crate::model::WatchResponse>,
1541}
1542impl GetIdentitySelfProfileOutput {
1543 pub fn identity(&self) -> std::option::Option<&crate::model::IdentityProfile> {
1545 self.identity.as_ref()
1546 }
1547 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
1549 self.watch.as_ref()
1550 }
1551}
1552impl std::fmt::Debug for GetIdentitySelfProfileOutput {
1553 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1554 let mut formatter = f.debug_struct("GetIdentitySelfProfileOutput");
1555 formatter.field("identity", &self.identity);
1556 formatter.field("watch", &self.watch);
1557 formatter.finish()
1558 }
1559}
1560pub mod get_identity_self_profile_output {
1562 #[non_exhaustive]
1564 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1565 pub struct Builder {
1566 pub(crate) identity: std::option::Option<crate::model::IdentityProfile>,
1567 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
1568 }
1569 impl Builder {
1570 pub fn identity(mut self, input: crate::model::IdentityProfile) -> Self {
1572 self.identity = Some(input);
1573 self
1574 }
1575 pub fn set_identity(
1577 mut self,
1578 input: std::option::Option<crate::model::IdentityProfile>,
1579 ) -> Self {
1580 self.identity = input;
1581 self
1582 }
1583 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
1585 self.watch = Some(input);
1586 self
1587 }
1588 pub fn set_watch(
1590 mut self,
1591 input: std::option::Option<crate::model::WatchResponse>,
1592 ) -> Self {
1593 self.watch = input;
1594 self
1595 }
1596 pub fn build(self) -> crate::output::GetIdentitySelfProfileOutput {
1598 crate::output::GetIdentitySelfProfileOutput {
1599 identity: self.identity,
1600 watch: self.watch,
1601 }
1602 }
1603 }
1604}
1605impl GetIdentitySelfProfileOutput {
1606 pub fn builder() -> crate::output::get_identity_self_profile_output::Builder {
1608 crate::output::get_identity_self_profile_output::Builder::default()
1609 }
1610}
1611
1612#[allow(missing_docs)] #[non_exhaustive]
1614#[derive(std::clone::Clone, std::cmp::PartialEq)]
1615pub struct GetIdentityProfileOutput {
1616 pub identity: std::option::Option<crate::model::IdentityProfile>,
1618 pub watch: std::option::Option<crate::model::WatchResponse>,
1620}
1621impl GetIdentityProfileOutput {
1622 pub fn identity(&self) -> std::option::Option<&crate::model::IdentityProfile> {
1624 self.identity.as_ref()
1625 }
1626 pub fn watch(&self) -> std::option::Option<&crate::model::WatchResponse> {
1628 self.watch.as_ref()
1629 }
1630}
1631impl std::fmt::Debug for GetIdentityProfileOutput {
1632 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633 let mut formatter = f.debug_struct("GetIdentityProfileOutput");
1634 formatter.field("identity", &self.identity);
1635 formatter.field("watch", &self.watch);
1636 formatter.finish()
1637 }
1638}
1639pub mod get_identity_profile_output {
1641 #[non_exhaustive]
1643 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1644 pub struct Builder {
1645 pub(crate) identity: std::option::Option<crate::model::IdentityProfile>,
1646 pub(crate) watch: std::option::Option<crate::model::WatchResponse>,
1647 }
1648 impl Builder {
1649 pub fn identity(mut self, input: crate::model::IdentityProfile) -> Self {
1651 self.identity = Some(input);
1652 self
1653 }
1654 pub fn set_identity(
1656 mut self,
1657 input: std::option::Option<crate::model::IdentityProfile>,
1658 ) -> Self {
1659 self.identity = input;
1660 self
1661 }
1662 pub fn watch(mut self, input: crate::model::WatchResponse) -> Self {
1664 self.watch = Some(input);
1665 self
1666 }
1667 pub fn set_watch(
1669 mut self,
1670 input: std::option::Option<crate::model::WatchResponse>,
1671 ) -> Self {
1672 self.watch = input;
1673 self
1674 }
1675 pub fn build(self) -> crate::output::GetIdentityProfileOutput {
1677 crate::output::GetIdentityProfileOutput {
1678 identity: self.identity,
1679 watch: self.watch,
1680 }
1681 }
1682 }
1683}
1684impl GetIdentityProfileOutput {
1685 pub fn builder() -> crate::output::get_identity_profile_output::Builder {
1687 crate::output::get_identity_profile_output::Builder::default()
1688 }
1689}
1690
1691#[allow(missing_docs)] #[non_exhaustive]
1693#[derive(std::clone::Clone, std::cmp::PartialEq)]
1694pub struct SetupIdentityOutput {
1695 pub identity_token: std::option::Option<std::string::String>,
1697 pub identity_token_expire_ts: std::option::Option<aws_smithy_types::DateTime>,
1699 pub identity: std::option::Option<crate::model::IdentityProfile>,
1701 pub game_id: std::option::Option<std::string::String>,
1703}
1704impl SetupIdentityOutput {
1705 pub fn identity_token(&self) -> std::option::Option<&str> {
1707 self.identity_token.as_deref()
1708 }
1709 pub fn identity_token_expire_ts(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
1711 self.identity_token_expire_ts.as_ref()
1712 }
1713 pub fn identity(&self) -> std::option::Option<&crate::model::IdentityProfile> {
1715 self.identity.as_ref()
1716 }
1717 pub fn game_id(&self) -> std::option::Option<&str> {
1719 self.game_id.as_deref()
1720 }
1721}
1722impl std::fmt::Debug for SetupIdentityOutput {
1723 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1724 let mut formatter = f.debug_struct("SetupIdentityOutput");
1725 formatter.field("identity_token", &"*** Sensitive Data Redacted ***");
1726 formatter.field("identity_token_expire_ts", &self.identity_token_expire_ts);
1727 formatter.field("identity", &self.identity);
1728 formatter.field("game_id", &self.game_id);
1729 formatter.finish()
1730 }
1731}
1732pub mod setup_identity_output {
1734 #[non_exhaustive]
1736 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1737 pub struct Builder {
1738 pub(crate) identity_token: std::option::Option<std::string::String>,
1739 pub(crate) identity_token_expire_ts: std::option::Option<aws_smithy_types::DateTime>,
1740 pub(crate) identity: std::option::Option<crate::model::IdentityProfile>,
1741 pub(crate) game_id: std::option::Option<std::string::String>,
1742 }
1743 impl Builder {
1744 pub fn identity_token(mut self, input: impl Into<std::string::String>) -> Self {
1746 self.identity_token = Some(input.into());
1747 self
1748 }
1749 pub fn set_identity_token(
1751 mut self,
1752 input: std::option::Option<std::string::String>,
1753 ) -> Self {
1754 self.identity_token = input;
1755 self
1756 }
1757 pub fn identity_token_expire_ts(mut self, input: aws_smithy_types::DateTime) -> Self {
1759 self.identity_token_expire_ts = Some(input);
1760 self
1761 }
1762 pub fn set_identity_token_expire_ts(
1764 mut self,
1765 input: std::option::Option<aws_smithy_types::DateTime>,
1766 ) -> Self {
1767 self.identity_token_expire_ts = input;
1768 self
1769 }
1770 pub fn identity(mut self, input: crate::model::IdentityProfile) -> Self {
1772 self.identity = Some(input);
1773 self
1774 }
1775 pub fn set_identity(
1777 mut self,
1778 input: std::option::Option<crate::model::IdentityProfile>,
1779 ) -> Self {
1780 self.identity = input;
1781 self
1782 }
1783 pub fn game_id(mut self, input: impl Into<std::string::String>) -> Self {
1785 self.game_id = Some(input.into());
1786 self
1787 }
1788 pub fn set_game_id(mut self, input: std::option::Option<std::string::String>) -> Self {
1790 self.game_id = input;
1791 self
1792 }
1793 pub fn build(self) -> crate::output::SetupIdentityOutput {
1795 crate::output::SetupIdentityOutput {
1796 identity_token: self.identity_token,
1797 identity_token_expire_ts: self.identity_token_expire_ts,
1798 identity: self.identity,
1799 game_id: self.game_id,
1800 }
1801 }
1802 }
1803}
1804impl SetupIdentityOutput {
1805 pub fn builder() -> crate::output::setup_identity_output::Builder {
1807 crate::output::setup_identity_output::Builder::default()
1808 }
1809}