1#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
9pub struct CancelGameLink {
10 _private: (),
11}
12impl CancelGameLink {
13 pub fn builder() -> crate::input::cancel_game_link_input::Builder {
15 crate::input::cancel_game_link_input::Builder::default()
16 }
17 pub fn new() -> Self {
19 Self { _private: () }
20 }
21}
22impl aws_smithy_http::response::ParseStrictResponse for CancelGameLink {
23 type Output =
24 std::result::Result<crate::output::CancelGameLinkOutput, crate::error::CancelGameLinkError>;
25 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
26 if !response.status().is_success() && response.status().as_u16() != 200 {
27 crate::operation_deser::parse_cancel_game_link_error(response)
28 } else {
29 crate::operation_deser::parse_cancel_game_link_response(response)
30 }
31 }
32}
33
34#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
41pub struct CompleteGameLink {
42 _private: (),
43}
44impl CompleteGameLink {
45 pub fn builder() -> crate::input::complete_game_link_input::Builder {
47 crate::input::complete_game_link_input::Builder::default()
48 }
49 pub fn new() -> Self {
51 Self { _private: () }
52 }
53}
54impl aws_smithy_http::response::ParseStrictResponse for CompleteGameLink {
55 type Output = std::result::Result<
56 crate::output::CompleteGameLinkOutput,
57 crate::error::CompleteGameLinkError,
58 >;
59 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
60 if !response.status().is_success() && response.status().as_u16() != 200 {
61 crate::operation_deser::parse_complete_game_link_error(response)
62 } else {
63 crate::operation_deser::parse_complete_game_link_response(response)
64 }
65 }
66}
67
68#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
75pub struct CompleteIdentityAvatarUpload {
76 _private: (),
77}
78impl CompleteIdentityAvatarUpload {
79 pub fn builder() -> crate::input::complete_identity_avatar_upload_input::Builder {
81 crate::input::complete_identity_avatar_upload_input::Builder::default()
82 }
83 pub fn new() -> Self {
85 Self { _private: () }
86 }
87}
88impl aws_smithy_http::response::ParseStrictResponse for CompleteIdentityAvatarUpload {
89 type Output = std::result::Result<
90 crate::output::CompleteIdentityAvatarUploadOutput,
91 crate::error::CompleteIdentityAvatarUploadError,
92 >;
93 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
94 if !response.status().is_success() && response.status().as_u16() != 200 {
95 crate::operation_deser::parse_complete_identity_avatar_upload_error(response)
96 } else {
97 crate::operation_deser::parse_complete_identity_avatar_upload_response(response)
98 }
99 }
100}
101
102#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
109pub struct FollowIdentity {
110 _private: (),
111}
112impl FollowIdentity {
113 pub fn builder() -> crate::input::follow_identity_input::Builder {
115 crate::input::follow_identity_input::Builder::default()
116 }
117 pub fn new() -> Self {
119 Self { _private: () }
120 }
121}
122impl aws_smithy_http::response::ParseStrictResponse for FollowIdentity {
123 type Output =
124 std::result::Result<crate::output::FollowIdentityOutput, crate::error::FollowIdentityError>;
125 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
126 if !response.status().is_success() && response.status().as_u16() != 200 {
127 crate::operation_deser::parse_follow_identity_error(response)
128 } else {
129 crate::operation_deser::parse_follow_identity_response(response)
130 }
131 }
132}
133
134#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
141pub struct GetGameLink {
142 _private: (),
143}
144impl GetGameLink {
145 pub fn builder() -> crate::input::get_game_link_input::Builder {
147 crate::input::get_game_link_input::Builder::default()
148 }
149 pub fn new() -> Self {
151 Self { _private: () }
152 }
153}
154impl aws_smithy_http::response::ParseStrictResponse for GetGameLink {
155 type Output =
156 std::result::Result<crate::output::GetGameLinkOutput, crate::error::GetGameLinkError>;
157 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
158 if !response.status().is_success() && response.status().as_u16() != 200 {
159 crate::operation_deser::parse_get_game_link_error(response)
160 } else {
161 crate::operation_deser::parse_get_game_link_response(response)
162 }
163 }
164}
165
166#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
173pub struct GetIdentityHandles {
174 _private: (),
175}
176impl GetIdentityHandles {
177 pub fn builder() -> crate::input::get_identity_handles_input::Builder {
179 crate::input::get_identity_handles_input::Builder::default()
180 }
181 pub fn new() -> Self {
183 Self { _private: () }
184 }
185}
186impl aws_smithy_http::response::ParseStrictResponse for GetIdentityHandles {
187 type Output = std::result::Result<
188 crate::output::GetIdentityHandlesOutput,
189 crate::error::GetIdentityHandlesError,
190 >;
191 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
192 if !response.status().is_success() && response.status().as_u16() != 200 {
193 crate::operation_deser::parse_get_identity_handles_error(response)
194 } else {
195 crate::operation_deser::parse_get_identity_handles_response(response)
196 }
197 }
198}
199
200#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
207pub struct GetIdentityProfile {
208 _private: (),
209}
210impl GetIdentityProfile {
211 pub fn builder() -> crate::input::get_identity_profile_input::Builder {
213 crate::input::get_identity_profile_input::Builder::default()
214 }
215 pub fn new() -> Self {
217 Self { _private: () }
218 }
219}
220impl aws_smithy_http::response::ParseStrictResponse for GetIdentityProfile {
221 type Output = std::result::Result<
222 crate::output::GetIdentityProfileOutput,
223 crate::error::GetIdentityProfileError,
224 >;
225 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
226 if !response.status().is_success() && response.status().as_u16() != 200 {
227 crate::operation_deser::parse_get_identity_profile_error(response)
228 } else {
229 crate::operation_deser::parse_get_identity_profile_response(response)
230 }
231 }
232}
233
234#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
241pub struct GetIdentitySelfProfile {
242 _private: (),
243}
244impl GetIdentitySelfProfile {
245 pub fn builder() -> crate::input::get_identity_self_profile_input::Builder {
247 crate::input::get_identity_self_profile_input::Builder::default()
248 }
249 pub fn new() -> Self {
251 Self { _private: () }
252 }
253}
254impl aws_smithy_http::response::ParseStrictResponse for GetIdentitySelfProfile {
255 type Output = std::result::Result<
256 crate::output::GetIdentitySelfProfileOutput,
257 crate::error::GetIdentitySelfProfileError,
258 >;
259 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
260 if !response.status().is_success() && response.status().as_u16() != 200 {
261 crate::operation_deser::parse_get_identity_self_profile_error(response)
262 } else {
263 crate::operation_deser::parse_get_identity_self_profile_response(response)
264 }
265 }
266}
267
268#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
275pub struct GetIdentitySummaries {
276 _private: (),
277}
278impl GetIdentitySummaries {
279 pub fn builder() -> crate::input::get_identity_summaries_input::Builder {
281 crate::input::get_identity_summaries_input::Builder::default()
282 }
283 pub fn new() -> Self {
285 Self { _private: () }
286 }
287}
288impl aws_smithy_http::response::ParseStrictResponse for GetIdentitySummaries {
289 type Output = std::result::Result<
290 crate::output::GetIdentitySummariesOutput,
291 crate::error::GetIdentitySummariesError,
292 >;
293 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
294 if !response.status().is_success() && response.status().as_u16() != 200 {
295 crate::operation_deser::parse_get_identity_summaries_error(response)
296 } else {
297 crate::operation_deser::parse_get_identity_summaries_response(response)
298 }
299 }
300}
301
302#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
309pub struct ListActivities {
310 _private: (),
311}
312impl ListActivities {
313 pub fn builder() -> crate::input::list_activities_input::Builder {
315 crate::input::list_activities_input::Builder::default()
316 }
317 pub fn new() -> Self {
319 Self { _private: () }
320 }
321}
322impl aws_smithy_http::response::ParseStrictResponse for ListActivities {
323 type Output =
324 std::result::Result<crate::output::ListActivitiesOutput, crate::error::ListActivitiesError>;
325 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
326 if !response.status().is_success() && response.status().as_u16() != 200 {
327 crate::operation_deser::parse_list_activities_error(response)
328 } else {
329 crate::operation_deser::parse_list_activities_response(response)
330 }
331 }
332}
333
334#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
341pub struct ListFollowers {
342 _private: (),
343}
344impl ListFollowers {
345 pub fn builder() -> crate::input::list_followers_input::Builder {
347 crate::input::list_followers_input::Builder::default()
348 }
349 pub fn new() -> Self {
351 Self { _private: () }
352 }
353}
354impl aws_smithy_http::response::ParseStrictResponse for ListFollowers {
355 type Output =
356 std::result::Result<crate::output::ListFollowersOutput, crate::error::ListFollowersError>;
357 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
358 if !response.status().is_success() && response.status().as_u16() != 200 {
359 crate::operation_deser::parse_list_followers_error(response)
360 } else {
361 crate::operation_deser::parse_list_followers_response(response)
362 }
363 }
364}
365
366#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
373pub struct ListFollowing {
374 _private: (),
375}
376impl ListFollowing {
377 pub fn builder() -> crate::input::list_following_input::Builder {
379 crate::input::list_following_input::Builder::default()
380 }
381 pub fn new() -> Self {
383 Self { _private: () }
384 }
385}
386impl aws_smithy_http::response::ParseStrictResponse for ListFollowing {
387 type Output =
388 std::result::Result<crate::output::ListFollowingOutput, crate::error::ListFollowingError>;
389 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
390 if !response.status().is_success() && response.status().as_u16() != 200 {
391 crate::operation_deser::parse_list_following_error(response)
392 } else {
393 crate::operation_deser::parse_list_following_response(response)
394 }
395 }
396}
397
398#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
405pub struct ListFriends {
406 _private: (),
407}
408impl ListFriends {
409 pub fn builder() -> crate::input::list_friends_input::Builder {
411 crate::input::list_friends_input::Builder::default()
412 }
413 pub fn new() -> Self {
415 Self { _private: () }
416 }
417}
418impl aws_smithy_http::response::ParseStrictResponse for ListFriends {
419 type Output =
420 std::result::Result<crate::output::ListFriendsOutput, crate::error::ListFriendsError>;
421 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
422 if !response.status().is_success() && response.status().as_u16() != 200 {
423 crate::operation_deser::parse_list_friends_error(response)
424 } else {
425 crate::operation_deser::parse_list_friends_response(response)
426 }
427 }
428}
429
430#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
437pub struct ListMutualFriends {
438 _private: (),
439}
440impl ListMutualFriends {
441 pub fn builder() -> crate::input::list_mutual_friends_input::Builder {
443 crate::input::list_mutual_friends_input::Builder::default()
444 }
445 pub fn new() -> Self {
447 Self { _private: () }
448 }
449}
450impl aws_smithy_http::response::ParseStrictResponse for ListMutualFriends {
451 type Output = std::result::Result<
452 crate::output::ListMutualFriendsOutput,
453 crate::error::ListMutualFriendsError,
454 >;
455 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
456 if !response.status().is_success() && response.status().as_u16() != 200 {
457 crate::operation_deser::parse_list_mutual_friends_error(response)
458 } else {
459 crate::operation_deser::parse_list_mutual_friends_response(response)
460 }
461 }
462}
463
464#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
471pub struct PrepareGameLink {
472 _private: (),
473}
474impl PrepareGameLink {
475 pub fn builder() -> crate::input::prepare_game_link_input::Builder {
477 crate::input::prepare_game_link_input::Builder::default()
478 }
479 pub fn new() -> Self {
481 Self { _private: () }
482 }
483}
484impl aws_smithy_http::response::ParseStrictResponse for PrepareGameLink {
485 type Output = std::result::Result<
486 crate::output::PrepareGameLinkOutput,
487 crate::error::PrepareGameLinkError,
488 >;
489 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
490 if !response.status().is_success() && response.status().as_u16() != 200 {
491 crate::operation_deser::parse_prepare_game_link_error(response)
492 } else {
493 crate::operation_deser::parse_prepare_game_link_response(response)
494 }
495 }
496}
497
498#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
505pub struct PrepareIdentityAvatarUpload {
506 _private: (),
507}
508impl PrepareIdentityAvatarUpload {
509 pub fn builder() -> crate::input::prepare_identity_avatar_upload_input::Builder {
511 crate::input::prepare_identity_avatar_upload_input::Builder::default()
512 }
513 pub fn new() -> Self {
515 Self { _private: () }
516 }
517}
518impl aws_smithy_http::response::ParseStrictResponse for PrepareIdentityAvatarUpload {
519 type Output = std::result::Result<
520 crate::output::PrepareIdentityAvatarUploadOutput,
521 crate::error::PrepareIdentityAvatarUploadError,
522 >;
523 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
524 if !response.status().is_success() && response.status().as_u16() != 200 {
525 crate::operation_deser::parse_prepare_identity_avatar_upload_error(response)
526 } else {
527 crate::operation_deser::parse_prepare_identity_avatar_upload_response(response)
528 }
529 }
530}
531
532#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
539pub struct RemoveIdentityGameActivity {
540 _private: (),
541}
542impl RemoveIdentityGameActivity {
543 pub fn builder() -> crate::input::remove_identity_game_activity_input::Builder {
545 crate::input::remove_identity_game_activity_input::Builder::default()
546 }
547 pub fn new() -> Self {
549 Self { _private: () }
550 }
551}
552impl aws_smithy_http::response::ParseStrictResponse for RemoveIdentityGameActivity {
553 type Output = std::result::Result<
554 crate::output::RemoveIdentityGameActivityOutput,
555 crate::error::RemoveIdentityGameActivityError,
556 >;
557 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
558 if !response.status().is_success() && response.status().as_u16() != 200 {
559 crate::operation_deser::parse_remove_identity_game_activity_error(response)
560 } else {
561 crate::operation_deser::parse_remove_identity_game_activity_response(response)
562 }
563 }
564}
565
566#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
573pub struct ReportIdentity {
574 _private: (),
575}
576impl ReportIdentity {
577 pub fn builder() -> crate::input::report_identity_input::Builder {
579 crate::input::report_identity_input::Builder::default()
580 }
581 pub fn new() -> Self {
583 Self { _private: () }
584 }
585}
586impl aws_smithy_http::response::ParseStrictResponse for ReportIdentity {
587 type Output =
588 std::result::Result<crate::output::ReportIdentityOutput, crate::error::ReportIdentityError>;
589 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
590 if !response.status().is_success() && response.status().as_u16() != 200 {
591 crate::operation_deser::parse_report_identity_error(response)
592 } else {
593 crate::operation_deser::parse_report_identity_response(response)
594 }
595 }
596}
597
598#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
605pub struct SearchIdentities {
606 _private: (),
607}
608impl SearchIdentities {
609 pub fn builder() -> crate::input::search_identities_input::Builder {
611 crate::input::search_identities_input::Builder::default()
612 }
613 pub fn new() -> Self {
615 Self { _private: () }
616 }
617}
618impl aws_smithy_http::response::ParseStrictResponse for SearchIdentities {
619 type Output = std::result::Result<
620 crate::output::SearchIdentitiesOutput,
621 crate::error::SearchIdentitiesError,
622 >;
623 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
624 if !response.status().is_success() && response.status().as_u16() != 200 {
625 crate::operation_deser::parse_search_identities_error(response)
626 } else {
627 crate::operation_deser::parse_search_identities_response(response)
628 }
629 }
630}
631
632#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
639pub struct SetIdentityGameActivity {
640 _private: (),
641}
642impl SetIdentityGameActivity {
643 pub fn builder() -> crate::input::set_identity_game_activity_input::Builder {
645 crate::input::set_identity_game_activity_input::Builder::default()
646 }
647 pub fn new() -> Self {
649 Self { _private: () }
650 }
651}
652impl aws_smithy_http::response::ParseStrictResponse for SetIdentityGameActivity {
653 type Output = std::result::Result<
654 crate::output::SetIdentityGameActivityOutput,
655 crate::error::SetIdentityGameActivityError,
656 >;
657 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
658 if !response.status().is_success() && response.status().as_u16() != 200 {
659 crate::operation_deser::parse_set_identity_game_activity_error(response)
660 } else {
661 crate::operation_deser::parse_set_identity_game_activity_response(response)
662 }
663 }
664}
665
666#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
673pub struct SetupIdentity {
674 _private: (),
675}
676impl SetupIdentity {
677 pub fn builder() -> crate::input::setup_identity_input::Builder {
679 crate::input::setup_identity_input::Builder::default()
680 }
681 pub fn new() -> Self {
683 Self { _private: () }
684 }
685}
686impl aws_smithy_http::response::ParseStrictResponse for SetupIdentity {
687 type Output =
688 std::result::Result<crate::output::SetupIdentityOutput, crate::error::SetupIdentityError>;
689 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
690 if !response.status().is_success() && response.status().as_u16() != 200 {
691 crate::operation_deser::parse_setup_identity_error(response)
692 } else {
693 crate::operation_deser::parse_setup_identity_response(response)
694 }
695 }
696}
697
698#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
705pub struct SignupForBeta {
706 _private: (),
707}
708impl SignupForBeta {
709 pub fn builder() -> crate::input::signup_for_beta_input::Builder {
711 crate::input::signup_for_beta_input::Builder::default()
712 }
713 pub fn new() -> Self {
715 Self { _private: () }
716 }
717}
718impl aws_smithy_http::response::ParseStrictResponse for SignupForBeta {
719 type Output =
720 std::result::Result<crate::output::SignupForBetaOutput, crate::error::SignupForBetaError>;
721 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
722 if !response.status().is_success() && response.status().as_u16() != 200 {
723 crate::operation_deser::parse_signup_for_beta_error(response)
724 } else {
725 crate::operation_deser::parse_signup_for_beta_response(response)
726 }
727 }
728}
729
730#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
737pub struct UnfollowIdentity {
738 _private: (),
739}
740impl UnfollowIdentity {
741 pub fn builder() -> crate::input::unfollow_identity_input::Builder {
743 crate::input::unfollow_identity_input::Builder::default()
744 }
745 pub fn new() -> Self {
747 Self { _private: () }
748 }
749}
750impl aws_smithy_http::response::ParseStrictResponse for UnfollowIdentity {
751 type Output = std::result::Result<
752 crate::output::UnfollowIdentityOutput,
753 crate::error::UnfollowIdentityError,
754 >;
755 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
756 if !response.status().is_success() && response.status().as_u16() != 200 {
757 crate::operation_deser::parse_unfollow_identity_error(response)
758 } else {
759 crate::operation_deser::parse_unfollow_identity_response(response)
760 }
761 }
762}
763
764#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
771pub struct UpdateIdentityProfile {
772 _private: (),
773}
774impl UpdateIdentityProfile {
775 pub fn builder() -> crate::input::update_identity_profile_input::Builder {
777 crate::input::update_identity_profile_input::Builder::default()
778 }
779 pub fn new() -> Self {
781 Self { _private: () }
782 }
783}
784impl aws_smithy_http::response::ParseStrictResponse for UpdateIdentityProfile {
785 type Output = std::result::Result<
786 crate::output::UpdateIdentityProfileOutput,
787 crate::error::UpdateIdentityProfileError,
788 >;
789 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
790 if !response.status().is_success() && response.status().as_u16() != 200 {
791 crate::operation_deser::parse_update_identity_profile_error(response)
792 } else {
793 crate::operation_deser::parse_update_identity_profile_response(response)
794 }
795 }
796}
797
798#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
805pub struct UpdateIdentityStatus {
806 _private: (),
807}
808impl UpdateIdentityStatus {
809 pub fn builder() -> crate::input::update_identity_status_input::Builder {
811 crate::input::update_identity_status_input::Builder::default()
812 }
813 pub fn new() -> Self {
815 Self { _private: () }
816 }
817}
818impl aws_smithy_http::response::ParseStrictResponse for UpdateIdentityStatus {
819 type Output = std::result::Result<
820 crate::output::UpdateIdentityStatusOutput,
821 crate::error::UpdateIdentityStatusError,
822 >;
823 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
824 if !response.status().is_success() && response.status().as_u16() != 200 {
825 crate::operation_deser::parse_update_identity_status_error(response)
826 } else {
827 crate::operation_deser::parse_update_identity_status_response(response)
828 }
829 }
830}
831
832#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
839pub struct ValidateIdentityProfile {
840 _private: (),
841}
842impl ValidateIdentityProfile {
843 pub fn builder() -> crate::input::validate_identity_profile_input::Builder {
845 crate::input::validate_identity_profile_input::Builder::default()
846 }
847 pub fn new() -> Self {
849 Self { _private: () }
850 }
851}
852impl aws_smithy_http::response::ParseStrictResponse for ValidateIdentityProfile {
853 type Output = std::result::Result<
854 crate::output::ValidateIdentityProfileOutput,
855 crate::error::ValidateIdentityProfileError,
856 >;
857 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
858 if !response.status().is_success() && response.status().as_u16() != 200 {
859 crate::operation_deser::parse_validate_identity_profile_error(response)
860 } else {
861 crate::operation_deser::parse_validate_identity_profile_response(response)
862 }
863 }
864}
865
866#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
873pub struct WatchEvents {
874 _private: (),
875}
876impl WatchEvents {
877 pub fn builder() -> crate::input::watch_events_input::Builder {
879 crate::input::watch_events_input::Builder::default()
880 }
881 pub fn new() -> Self {
883 Self { _private: () }
884 }
885}
886impl aws_smithy_http::response::ParseStrictResponse for WatchEvents {
887 type Output =
888 std::result::Result<crate::output::WatchEventsOutput, crate::error::WatchEventsError>;
889 fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
890 if !response.status().is_success() && response.status().as_u16() != 200 {
891 crate::operation_deser::parse_watch_events_error(response)
892 } else {
893 crate::operation_deser::parse_watch_events_response(response)
894 }
895 }
896}