1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " Errors returned by `ActivityGovernor/AcquireWakeLease` and `AcquireWakeLease2`.\n"]
8 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 #[repr(u32)]
10 pub enum AcquireWakeLeaseError {
11 Internal = 1,
12 InvalidName = 2,
13 ServerTokenRequired = 3,
14 InvalidPreviousToken = 4,
15 UnknownOrdinal_(u32) = 5,
16 }
17 impl ::std::convert::From<u32> for AcquireWakeLeaseError {
18 fn from(value: u32) -> Self {
19 match value {
20 1 => Self::Internal,
21 2 => Self::InvalidName,
22 3 => Self::ServerTokenRequired,
23 4 => Self::InvalidPreviousToken,
24
25 _ => Self::UnknownOrdinal_(value),
26 }
27 }
28 }
29
30 impl ::std::convert::From<AcquireWakeLeaseError> for u32 {
31 fn from(value: AcquireWakeLeaseError) -> Self {
32 match value {
33 AcquireWakeLeaseError::Internal => 1,
34 AcquireWakeLeaseError::InvalidName => 2,
35 AcquireWakeLeaseError::ServerTokenRequired => 3,
36 AcquireWakeLeaseError::InvalidPreviousToken => 4,
37
38 AcquireWakeLeaseError::UnknownOrdinal_(value) => value,
39 }
40 }
41 }
42
43 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AcquireWakeLeaseError, ___E>
44 for AcquireWakeLeaseError
45 where
46 ___E: ?Sized,
47 {
48 #[inline]
49 fn encode(
50 self,
51 encoder: &mut ___E,
52 out: &mut ::core::mem::MaybeUninit<crate::wire::AcquireWakeLeaseError>,
53 _: (),
54 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
55 ::fidl_next::Encode::encode(&self, encoder, out, ())
56 }
57 }
58
59 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AcquireWakeLeaseError, ___E>
60 for &'a AcquireWakeLeaseError
61 where
62 ___E: ?Sized,
63 {
64 #[inline]
65 fn encode(
66 self,
67 encoder: &mut ___E,
68 out: &mut ::core::mem::MaybeUninit<crate::wire::AcquireWakeLeaseError>,
69 _: (),
70 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
71 ::fidl_next::munge!(let crate::wire::AcquireWakeLeaseError { value } = out);
72 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
73 AcquireWakeLeaseError::Internal => 1,
74
75 AcquireWakeLeaseError::InvalidName => 2,
76
77 AcquireWakeLeaseError::ServerTokenRequired => 3,
78
79 AcquireWakeLeaseError::InvalidPreviousToken => 4,
80
81 AcquireWakeLeaseError::UnknownOrdinal_(value) => value,
82 }));
83
84 Ok(())
85 }
86 }
87
88 impl ::core::convert::From<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
89 fn from(wire: crate::wire::AcquireWakeLeaseError) -> Self {
90 match u32::from(wire.value) {
91 1 => Self::Internal,
92
93 2 => Self::InvalidName,
94
95 3 => Self::ServerTokenRequired,
96
97 4 => Self::InvalidPreviousToken,
98
99 value => Self::UnknownOrdinal_(value),
100 }
101 }
102 }
103
104 impl ::fidl_next::FromWire<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
105 #[inline]
106 fn from_wire(wire: crate::wire::AcquireWakeLeaseError) -> Self {
107 Self::from(wire)
108 }
109 }
110
111 impl ::fidl_next::FromWireRef<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
112 #[inline]
113 fn from_wire_ref(wire: &crate::wire::AcquireWakeLeaseError) -> Self {
114 Self::from(*wire)
115 }
116 }
117
118 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
119 pub struct ActivityGovernorAcquireWakeLeaseRequest {
120 pub name: ::std::string::String,
121 }
122
123 unsafe impl<___E>
124 ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>
125 for ActivityGovernorAcquireWakeLeaseRequest
126 where
127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
128 ___E: ::fidl_next::Encoder,
129 {
130 #[inline]
131 fn encode(
132 self,
133 encoder_: &mut ___E,
134 out_: &mut ::core::mem::MaybeUninit<
135 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
136 >,
137 _: (),
138 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
139 ::fidl_next::munge! {
140 let crate::wire::ActivityGovernorAcquireWakeLeaseRequest {
141 name,
142
143 } = out_;
144 }
145
146 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
147
148 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
149 ::fidl_next::Constrained::validate(_field, 64)?;
150
151 Ok(())
152 }
153 }
154
155 unsafe impl<'a, ___E>
156 ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>
157 for &'a ActivityGovernorAcquireWakeLeaseRequest
158 where
159 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
160 ___E: ::fidl_next::Encoder,
161 {
162 #[inline]
163 fn encode(
164 self,
165 encoder_: &mut ___E,
166 out_: &mut ::core::mem::MaybeUninit<
167 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
168 >,
169 _: (),
170 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
171 ::fidl_next::munge! {
172 let crate::wire::ActivityGovernorAcquireWakeLeaseRequest {
173 name,
174
175 } = out_;
176 }
177
178 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
179
180 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
181 ::fidl_next::Constrained::validate(_field, 64)?;
182
183 Ok(())
184 }
185 }
186
187 unsafe impl<___E>
188 ::fidl_next::EncodeOption<
189 ::fidl_next::wire::Box<
190 'static,
191 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
192 >,
193 ___E,
194 > for ActivityGovernorAcquireWakeLeaseRequest
195 where
196 ___E: ::fidl_next::Encoder + ?Sized,
197 ActivityGovernorAcquireWakeLeaseRequest: ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>,
198 {
199 #[inline]
200 fn encode_option(
201 this: ::core::option::Option<Self>,
202 encoder: &mut ___E,
203 out: &mut ::core::mem::MaybeUninit<
204 ::fidl_next::wire::Box<
205 'static,
206 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
207 >,
208 >,
209 _: (),
210 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
211 if let Some(inner) = this {
212 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
213 ::fidl_next::wire::Box::encode_present(out);
214 } else {
215 ::fidl_next::wire::Box::encode_absent(out);
216 }
217
218 Ok(())
219 }
220 }
221
222 unsafe impl<'a, ___E>
223 ::fidl_next::EncodeOption<
224 ::fidl_next::wire::Box<
225 'static,
226 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
227 >,
228 ___E,
229 > for &'a ActivityGovernorAcquireWakeLeaseRequest
230 where
231 ___E: ::fidl_next::Encoder + ?Sized,
232 &'a ActivityGovernorAcquireWakeLeaseRequest: ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>,
233 {
234 #[inline]
235 fn encode_option(
236 this: ::core::option::Option<Self>,
237 encoder: &mut ___E,
238 out: &mut ::core::mem::MaybeUninit<
239 ::fidl_next::wire::Box<
240 'static,
241 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
242 >,
243 >,
244 _: (),
245 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
246 if let Some(inner) = this {
247 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
248 ::fidl_next::wire::Box::encode_present(out);
249 } else {
250 ::fidl_next::wire::Box::encode_absent(out);
251 }
252
253 Ok(())
254 }
255 }
256
257 impl<'de> ::fidl_next::FromWire<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>>
258 for ActivityGovernorAcquireWakeLeaseRequest
259 {
260 #[inline]
261 fn from_wire(wire: crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>) -> Self {
262 Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
263 }
264 }
265
266 impl<'de> ::fidl_next::FromWireRef<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>>
267 for ActivityGovernorAcquireWakeLeaseRequest
268 {
269 #[inline]
270 fn from_wire_ref(wire: &crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>) -> Self {
271 Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
272 }
273 }
274
275 #[doc = " Error codes for responses from `RegisterSuspendBlocker` in\n [`fuchsia.power.system/ActivityGovernor`].\n"]
276 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
277 #[repr(u32)]
278 pub enum RegisterSuspendBlockerError {
279 Internal = 1,
280 InvalidArgs = 2,
281 UnknownOrdinal_(u32) = 3,
282 }
283 impl ::std::convert::From<u32> for RegisterSuspendBlockerError {
284 fn from(value: u32) -> Self {
285 match value {
286 1 => Self::Internal,
287 2 => Self::InvalidArgs,
288
289 _ => Self::UnknownOrdinal_(value),
290 }
291 }
292 }
293
294 impl ::std::convert::From<RegisterSuspendBlockerError> for u32 {
295 fn from(value: RegisterSuspendBlockerError) -> Self {
296 match value {
297 RegisterSuspendBlockerError::Internal => 1,
298 RegisterSuspendBlockerError::InvalidArgs => 2,
299
300 RegisterSuspendBlockerError::UnknownOrdinal_(value) => value,
301 }
302 }
303 }
304
305 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RegisterSuspendBlockerError, ___E>
306 for RegisterSuspendBlockerError
307 where
308 ___E: ?Sized,
309 {
310 #[inline]
311 fn encode(
312 self,
313 encoder: &mut ___E,
314 out: &mut ::core::mem::MaybeUninit<crate::wire::RegisterSuspendBlockerError>,
315 _: (),
316 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
317 ::fidl_next::Encode::encode(&self, encoder, out, ())
318 }
319 }
320
321 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RegisterSuspendBlockerError, ___E>
322 for &'a RegisterSuspendBlockerError
323 where
324 ___E: ?Sized,
325 {
326 #[inline]
327 fn encode(
328 self,
329 encoder: &mut ___E,
330 out: &mut ::core::mem::MaybeUninit<crate::wire::RegisterSuspendBlockerError>,
331 _: (),
332 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
333 ::fidl_next::munge!(let crate::wire::RegisterSuspendBlockerError { value } = out);
334 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
335 RegisterSuspendBlockerError::Internal => 1,
336
337 RegisterSuspendBlockerError::InvalidArgs => 2,
338
339 RegisterSuspendBlockerError::UnknownOrdinal_(value) => value,
340 }));
341
342 Ok(())
343 }
344 }
345
346 impl ::core::convert::From<crate::wire::RegisterSuspendBlockerError>
347 for RegisterSuspendBlockerError
348 {
349 fn from(wire: crate::wire::RegisterSuspendBlockerError) -> Self {
350 match u32::from(wire.value) {
351 1 => Self::Internal,
352
353 2 => Self::InvalidArgs,
354
355 value => Self::UnknownOrdinal_(value),
356 }
357 }
358 }
359
360 impl ::fidl_next::FromWire<crate::wire::RegisterSuspendBlockerError>
361 for RegisterSuspendBlockerError
362 {
363 #[inline]
364 fn from_wire(wire: crate::wire::RegisterSuspendBlockerError) -> Self {
365 Self::from(wire)
366 }
367 }
368
369 impl ::fidl_next::FromWireRef<crate::wire::RegisterSuspendBlockerError>
370 for RegisterSuspendBlockerError
371 {
372 #[inline]
373 fn from_wire_ref(wire: &crate::wire::RegisterSuspendBlockerError) -> Self {
374 Self::from(*wire)
375 }
376 }
377
378 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
379 pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
380 pub name: ::std::string::String,
381 }
382
383 unsafe impl<___E>
384 ::fidl_next::Encode<
385 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
386 ___E,
387 > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
388 where
389 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
390 ___E: ::fidl_next::Encoder,
391 {
392 #[inline]
393 fn encode(
394 self,
395 encoder_: &mut ___E,
396 out_: &mut ::core::mem::MaybeUninit<
397 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
398 >,
399 _: (),
400 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
401 ::fidl_next::munge! {
402 let crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
403 name,
404
405 } = out_;
406 }
407
408 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
409
410 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
411 ::fidl_next::Constrained::validate(_field, 64)?;
412
413 Ok(())
414 }
415 }
416
417 unsafe impl<'a, ___E>
418 ::fidl_next::Encode<
419 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
420 ___E,
421 > for &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
422 where
423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
424 ___E: ::fidl_next::Encoder,
425 {
426 #[inline]
427 fn encode(
428 self,
429 encoder_: &mut ___E,
430 out_: &mut ::core::mem::MaybeUninit<
431 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
432 >,
433 _: (),
434 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
435 ::fidl_next::munge! {
436 let crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
437 name,
438
439 } = out_;
440 }
441
442 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
443
444 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
445 ::fidl_next::Constrained::validate(_field, 64)?;
446
447 Ok(())
448 }
449 }
450
451 unsafe impl<___E>
452 ::fidl_next::EncodeOption<
453 ::fidl_next::wire::Box<
454 'static,
455 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
456 >,
457 ___E,
458 > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
459 where
460 ___E: ::fidl_next::Encoder + ?Sized,
461 ActivityGovernorAcquireUnmonitoredWakeLeaseRequest: ::fidl_next::Encode<
462 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
463 ___E,
464 >,
465 {
466 #[inline]
467 fn encode_option(
468 this: ::core::option::Option<Self>,
469 encoder: &mut ___E,
470 out: &mut ::core::mem::MaybeUninit<
471 ::fidl_next::wire::Box<
472 'static,
473 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
474 >,
475 >,
476 _: (),
477 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
478 if let Some(inner) = this {
479 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
480 ::fidl_next::wire::Box::encode_present(out);
481 } else {
482 ::fidl_next::wire::Box::encode_absent(out);
483 }
484
485 Ok(())
486 }
487 }
488
489 unsafe impl<'a, ___E>
490 ::fidl_next::EncodeOption<
491 ::fidl_next::wire::Box<
492 'static,
493 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
494 >,
495 ___E,
496 > for &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
497 where
498 ___E: ::fidl_next::Encoder + ?Sized,
499 &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest: ::fidl_next::Encode<
500 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
501 ___E,
502 >,
503 {
504 #[inline]
505 fn encode_option(
506 this: ::core::option::Option<Self>,
507 encoder: &mut ___E,
508 out: &mut ::core::mem::MaybeUninit<
509 ::fidl_next::wire::Box<
510 'static,
511 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
512 >,
513 >,
514 _: (),
515 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
516 if let Some(inner) = this {
517 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
518 ::fidl_next::wire::Box::encode_present(out);
519 } else {
520 ::fidl_next::wire::Box::encode_absent(out);
521 }
522
523 Ok(())
524 }
525 }
526
527 impl<'de>
528 ::fidl_next::FromWire<crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>>
529 for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
530 {
531 #[inline]
532 fn from_wire(
533 wire: crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
534 ) -> Self {
535 Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
536 }
537 }
538
539 impl<'de>
540 ::fidl_next::FromWireRef<
541 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
542 > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
543 {
544 #[inline]
545 fn from_wire_ref(
546 wire: &crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
547 ) -> Self {
548 Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
549 }
550 }
551
552 pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ();
553
554 pub type ActivityGovernorAcquireWakeLease2Response = ();
555
556 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
557 pub struct ActivityGovernorTakeApplicationActivityLeaseRequest {
558 pub name: ::std::string::String,
559 }
560
561 unsafe impl<___E>
562 ::fidl_next::Encode<
563 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
564 ___E,
565 > for ActivityGovernorTakeApplicationActivityLeaseRequest
566 where
567 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
568 ___E: ::fidl_next::Encoder,
569 {
570 #[inline]
571 fn encode(
572 self,
573 encoder_: &mut ___E,
574 out_: &mut ::core::mem::MaybeUninit<
575 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
576 >,
577 _: (),
578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
579 ::fidl_next::munge! {
580 let crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest {
581 name,
582
583 } = out_;
584 }
585
586 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
587
588 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
589 ::fidl_next::Constrained::validate(_field, 64)?;
590
591 Ok(())
592 }
593 }
594
595 unsafe impl<'a, ___E>
596 ::fidl_next::Encode<
597 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
598 ___E,
599 > for &'a ActivityGovernorTakeApplicationActivityLeaseRequest
600 where
601 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
602 ___E: ::fidl_next::Encoder,
603 {
604 #[inline]
605 fn encode(
606 self,
607 encoder_: &mut ___E,
608 out_: &mut ::core::mem::MaybeUninit<
609 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
610 >,
611 _: (),
612 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
613 ::fidl_next::munge! {
614 let crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest {
615 name,
616
617 } = out_;
618 }
619
620 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
621
622 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
623 ::fidl_next::Constrained::validate(_field, 64)?;
624
625 Ok(())
626 }
627 }
628
629 unsafe impl<___E>
630 ::fidl_next::EncodeOption<
631 ::fidl_next::wire::Box<
632 'static,
633 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
634 >,
635 ___E,
636 > for ActivityGovernorTakeApplicationActivityLeaseRequest
637 where
638 ___E: ::fidl_next::Encoder + ?Sized,
639 ActivityGovernorTakeApplicationActivityLeaseRequest: ::fidl_next::Encode<
640 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
641 ___E,
642 >,
643 {
644 #[inline]
645 fn encode_option(
646 this: ::core::option::Option<Self>,
647 encoder: &mut ___E,
648 out: &mut ::core::mem::MaybeUninit<
649 ::fidl_next::wire::Box<
650 'static,
651 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
652 >,
653 >,
654 _: (),
655 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
656 if let Some(inner) = this {
657 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
658 ::fidl_next::wire::Box::encode_present(out);
659 } else {
660 ::fidl_next::wire::Box::encode_absent(out);
661 }
662
663 Ok(())
664 }
665 }
666
667 unsafe impl<'a, ___E>
668 ::fidl_next::EncodeOption<
669 ::fidl_next::wire::Box<
670 'static,
671 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
672 >,
673 ___E,
674 > for &'a ActivityGovernorTakeApplicationActivityLeaseRequest
675 where
676 ___E: ::fidl_next::Encoder + ?Sized,
677 &'a ActivityGovernorTakeApplicationActivityLeaseRequest: ::fidl_next::Encode<
678 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
679 ___E,
680 >,
681 {
682 #[inline]
683 fn encode_option(
684 this: ::core::option::Option<Self>,
685 encoder: &mut ___E,
686 out: &mut ::core::mem::MaybeUninit<
687 ::fidl_next::wire::Box<
688 'static,
689 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
690 >,
691 >,
692 _: (),
693 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
694 if let Some(inner) = this {
695 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
696 ::fidl_next::wire::Box::encode_present(out);
697 } else {
698 ::fidl_next::wire::Box::encode_absent(out);
699 }
700
701 Ok(())
702 }
703 }
704
705 impl<'de>
706 ::fidl_next::FromWire<crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>>
707 for ActivityGovernorTakeApplicationActivityLeaseRequest
708 {
709 #[inline]
710 fn from_wire(
711 wire: crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
712 ) -> Self {
713 Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
714 }
715 }
716
717 impl<'de>
718 ::fidl_next::FromWireRef<
719 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
720 > for ActivityGovernorTakeApplicationActivityLeaseRequest
721 {
722 #[inline]
723 fn from_wire_ref(
724 wire: &crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
725 ) -> Self {
726 Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
727 }
728 }
729
730 #[doc = " Error codes for responses from `AddApplicationActivityDependency` in\n [`fuchsia.power.system/ActivityGovernor`].\n"]
731 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
732 #[repr(u32)]
733 pub enum AddApplicationActivityDependencyError {
734 AlreadyExists = 1,
735 Invalid = 2,
736 Internal = 3,
737 UnknownOrdinal_(u32) = 4,
738 }
739 impl ::std::convert::From<u32> for AddApplicationActivityDependencyError {
740 fn from(value: u32) -> Self {
741 match value {
742 1 => Self::AlreadyExists,
743 2 => Self::Invalid,
744 3 => Self::Internal,
745
746 _ => Self::UnknownOrdinal_(value),
747 }
748 }
749 }
750
751 impl ::std::convert::From<AddApplicationActivityDependencyError> for u32 {
752 fn from(value: AddApplicationActivityDependencyError) -> Self {
753 match value {
754 AddApplicationActivityDependencyError::AlreadyExists => 1,
755 AddApplicationActivityDependencyError::Invalid => 2,
756 AddApplicationActivityDependencyError::Internal => 3,
757
758 AddApplicationActivityDependencyError::UnknownOrdinal_(value) => value,
759 }
760 }
761 }
762
763 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AddApplicationActivityDependencyError, ___E>
764 for AddApplicationActivityDependencyError
765 where
766 ___E: ?Sized,
767 {
768 #[inline]
769 fn encode(
770 self,
771 encoder: &mut ___E,
772 out: &mut ::core::mem::MaybeUninit<crate::wire::AddApplicationActivityDependencyError>,
773 _: (),
774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
775 ::fidl_next::Encode::encode(&self, encoder, out, ())
776 }
777 }
778
779 unsafe impl<'a, ___E>
780 ::fidl_next::Encode<crate::wire::AddApplicationActivityDependencyError, ___E>
781 for &'a AddApplicationActivityDependencyError
782 where
783 ___E: ?Sized,
784 {
785 #[inline]
786 fn encode(
787 self,
788 encoder: &mut ___E,
789 out: &mut ::core::mem::MaybeUninit<crate::wire::AddApplicationActivityDependencyError>,
790 _: (),
791 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
792 ::fidl_next::munge!(let crate::wire::AddApplicationActivityDependencyError { value } = out);
793 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
794 AddApplicationActivityDependencyError::AlreadyExists => 1,
795
796 AddApplicationActivityDependencyError::Invalid => 2,
797
798 AddApplicationActivityDependencyError::Internal => 3,
799
800 AddApplicationActivityDependencyError::UnknownOrdinal_(value) => value,
801 }));
802
803 Ok(())
804 }
805 }
806
807 impl ::core::convert::From<crate::wire::AddApplicationActivityDependencyError>
808 for AddApplicationActivityDependencyError
809 {
810 fn from(wire: crate::wire::AddApplicationActivityDependencyError) -> Self {
811 match u32::from(wire.value) {
812 1 => Self::AlreadyExists,
813
814 2 => Self::Invalid,
815
816 3 => Self::Internal,
817
818 value => Self::UnknownOrdinal_(value),
819 }
820 }
821 }
822
823 impl ::fidl_next::FromWire<crate::wire::AddApplicationActivityDependencyError>
824 for AddApplicationActivityDependencyError
825 {
826 #[inline]
827 fn from_wire(wire: crate::wire::AddApplicationActivityDependencyError) -> Self {
828 Self::from(wire)
829 }
830 }
831
832 impl ::fidl_next::FromWireRef<crate::wire::AddApplicationActivityDependencyError>
833 for AddApplicationActivityDependencyError
834 {
835 #[inline]
836 fn from_wire_ref(wire: &crate::wire::AddApplicationActivityDependencyError) -> Self {
837 Self::from(*wire)
838 }
839 }
840
841 #[doc = " Error codes for responses from `AddExecutionStateDependency` in\n [`fuchsia.power.system/CpuElementManager`].\n"]
842 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
843 #[repr(u32)]
844 pub enum AddExecutionStateDependencyError {
845 InvalidArgs = 1,
846 BadState = 2,
847 UnknownOrdinal_(u32) = 3,
848 }
849 impl ::std::convert::From<u32> for AddExecutionStateDependencyError {
850 fn from(value: u32) -> Self {
851 match value {
852 1 => Self::InvalidArgs,
853 2 => Self::BadState,
854
855 _ => Self::UnknownOrdinal_(value),
856 }
857 }
858 }
859
860 impl ::std::convert::From<AddExecutionStateDependencyError> for u32 {
861 fn from(value: AddExecutionStateDependencyError) -> Self {
862 match value {
863 AddExecutionStateDependencyError::InvalidArgs => 1,
864 AddExecutionStateDependencyError::BadState => 2,
865
866 AddExecutionStateDependencyError::UnknownOrdinal_(value) => value,
867 }
868 }
869 }
870
871 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AddExecutionStateDependencyError, ___E>
872 for AddExecutionStateDependencyError
873 where
874 ___E: ?Sized,
875 {
876 #[inline]
877 fn encode(
878 self,
879 encoder: &mut ___E,
880 out: &mut ::core::mem::MaybeUninit<crate::wire::AddExecutionStateDependencyError>,
881 _: (),
882 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
883 ::fidl_next::Encode::encode(&self, encoder, out, ())
884 }
885 }
886
887 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AddExecutionStateDependencyError, ___E>
888 for &'a AddExecutionStateDependencyError
889 where
890 ___E: ?Sized,
891 {
892 #[inline]
893 fn encode(
894 self,
895 encoder: &mut ___E,
896 out: &mut ::core::mem::MaybeUninit<crate::wire::AddExecutionStateDependencyError>,
897 _: (),
898 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
899 ::fidl_next::munge!(let crate::wire::AddExecutionStateDependencyError { value } = out);
900 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
901 AddExecutionStateDependencyError::InvalidArgs => 1,
902
903 AddExecutionStateDependencyError::BadState => 2,
904
905 AddExecutionStateDependencyError::UnknownOrdinal_(value) => value,
906 }));
907
908 Ok(())
909 }
910 }
911
912 impl ::core::convert::From<crate::wire::AddExecutionStateDependencyError>
913 for AddExecutionStateDependencyError
914 {
915 fn from(wire: crate::wire::AddExecutionStateDependencyError) -> Self {
916 match u32::from(wire.value) {
917 1 => Self::InvalidArgs,
918
919 2 => Self::BadState,
920
921 value => Self::UnknownOrdinal_(value),
922 }
923 }
924 }
925
926 impl ::fidl_next::FromWire<crate::wire::AddExecutionStateDependencyError>
927 for AddExecutionStateDependencyError
928 {
929 #[inline]
930 fn from_wire(wire: crate::wire::AddExecutionStateDependencyError) -> Self {
931 Self::from(wire)
932 }
933 }
934
935 impl ::fidl_next::FromWireRef<crate::wire::AddExecutionStateDependencyError>
936 for AddExecutionStateDependencyError
937 {
938 #[inline]
939 fn from_wire_ref(wire: &crate::wire::AddExecutionStateDependencyError) -> Self {
940 Self::from(*wire)
941 }
942 }
943
944 #[doc = " Application activity power levels\n\n Elements that need to keep the system from suspending should take an assertive\n dependency on `ApplicationActivityLevel::ACTIVE`. When these components are\n performing work, they should request a lease to ensure the system remains\n active, and drop the lease when they are done.\n"]
945 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
946 #[repr(u8)]
947 pub enum ApplicationActivityLevel {
948 Inactive = 0,
949 Active = 1,
950 UnknownOrdinal_(u8) = 2,
951 }
952 impl ::std::convert::From<u8> for ApplicationActivityLevel {
953 fn from(value: u8) -> Self {
954 match value {
955 0 => Self::Inactive,
956 1 => Self::Active,
957
958 _ => Self::UnknownOrdinal_(value),
959 }
960 }
961 }
962
963 impl ::std::convert::From<ApplicationActivityLevel> for u8 {
964 fn from(value: ApplicationActivityLevel) -> Self {
965 match value {
966 ApplicationActivityLevel::Inactive => 0,
967 ApplicationActivityLevel::Active => 1,
968
969 ApplicationActivityLevel::UnknownOrdinal_(value) => value,
970 }
971 }
972 }
973
974 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ApplicationActivityLevel, ___E>
975 for ApplicationActivityLevel
976 where
977 ___E: ?Sized,
978 {
979 #[inline]
980 fn encode(
981 self,
982 encoder: &mut ___E,
983 out: &mut ::core::mem::MaybeUninit<crate::wire::ApplicationActivityLevel>,
984 _: (),
985 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
986 ::fidl_next::Encode::encode(&self, encoder, out, ())
987 }
988 }
989
990 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ApplicationActivityLevel, ___E>
991 for &'a ApplicationActivityLevel
992 where
993 ___E: ?Sized,
994 {
995 #[inline]
996 fn encode(
997 self,
998 encoder: &mut ___E,
999 out: &mut ::core::mem::MaybeUninit<crate::wire::ApplicationActivityLevel>,
1000 _: (),
1001 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1002 ::fidl_next::munge!(let crate::wire::ApplicationActivityLevel { value } = out);
1003 let _ = value.write(u8::from(match *self {
1004 ApplicationActivityLevel::Inactive => 0,
1005
1006 ApplicationActivityLevel::Active => 1,
1007
1008 ApplicationActivityLevel::UnknownOrdinal_(value) => value,
1009 }));
1010
1011 Ok(())
1012 }
1013 }
1014
1015 impl ::core::convert::From<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
1016 fn from(wire: crate::wire::ApplicationActivityLevel) -> Self {
1017 match u8::from(wire.value) {
1018 0 => Self::Inactive,
1019
1020 1 => Self::Active,
1021
1022 value => Self::UnknownOrdinal_(value),
1023 }
1024 }
1025 }
1026
1027 impl ::fidl_next::FromWire<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
1028 #[inline]
1029 fn from_wire(wire: crate::wire::ApplicationActivityLevel) -> Self {
1030 Self::from(wire)
1031 }
1032 }
1033
1034 impl ::fidl_next::FromWireRef<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
1035 #[inline]
1036 fn from_wire_ref(wire: &crate::wire::ApplicationActivityLevel) -> Self {
1037 Self::from(*wire)
1038 }
1039 }
1040
1041 pub type BootControlSetBootCompleteResponse = ();
1042
1043 pub type CpuElementManagerAddExecutionStateDependencyResponse = ();
1044
1045 #[doc = " CPU power levels\n\n Elements should take an assertive dependency on `CpuLevel::ACTIVE`\n to ensure that the element will be suspended before the CPU suspends.\n"]
1046 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1047 #[repr(u8)]
1048 pub enum CpuLevel {
1049 Inactive = 0,
1050 Active = 1,
1051 UnknownOrdinal_(u8) = 2,
1052 }
1053 impl ::std::convert::From<u8> for CpuLevel {
1054 fn from(value: u8) -> Self {
1055 match value {
1056 0 => Self::Inactive,
1057 1 => Self::Active,
1058
1059 _ => Self::UnknownOrdinal_(value),
1060 }
1061 }
1062 }
1063
1064 impl ::std::convert::From<CpuLevel> for u8 {
1065 fn from(value: CpuLevel) -> Self {
1066 match value {
1067 CpuLevel::Inactive => 0,
1068 CpuLevel::Active => 1,
1069
1070 CpuLevel::UnknownOrdinal_(value) => value,
1071 }
1072 }
1073 }
1074
1075 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CpuLevel, ___E> for CpuLevel
1076 where
1077 ___E: ?Sized,
1078 {
1079 #[inline]
1080 fn encode(
1081 self,
1082 encoder: &mut ___E,
1083 out: &mut ::core::mem::MaybeUninit<crate::wire::CpuLevel>,
1084 _: (),
1085 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1086 ::fidl_next::Encode::encode(&self, encoder, out, ())
1087 }
1088 }
1089
1090 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CpuLevel, ___E> for &'a CpuLevel
1091 where
1092 ___E: ?Sized,
1093 {
1094 #[inline]
1095 fn encode(
1096 self,
1097 encoder: &mut ___E,
1098 out: &mut ::core::mem::MaybeUninit<crate::wire::CpuLevel>,
1099 _: (),
1100 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1101 ::fidl_next::munge!(let crate::wire::CpuLevel { value } = out);
1102 let _ = value.write(u8::from(match *self {
1103 CpuLevel::Inactive => 0,
1104
1105 CpuLevel::Active => 1,
1106
1107 CpuLevel::UnknownOrdinal_(value) => value,
1108 }));
1109
1110 Ok(())
1111 }
1112 }
1113
1114 impl ::core::convert::From<crate::wire::CpuLevel> for CpuLevel {
1115 fn from(wire: crate::wire::CpuLevel) -> Self {
1116 match u8::from(wire.value) {
1117 0 => Self::Inactive,
1118
1119 1 => Self::Active,
1120
1121 value => Self::UnknownOrdinal_(value),
1122 }
1123 }
1124 }
1125
1126 impl ::fidl_next::FromWire<crate::wire::CpuLevel> for CpuLevel {
1127 #[inline]
1128 fn from_wire(wire: crate::wire::CpuLevel) -> Self {
1129 Self::from(wire)
1130 }
1131 }
1132
1133 impl ::fidl_next::FromWireRef<crate::wire::CpuLevel> for CpuLevel {
1134 #[inline]
1135 fn from_wire_ref(wire: &crate::wire::CpuLevel) -> Self {
1136 Self::from(*wire)
1137 }
1138 }
1139
1140 #[doc = " Execution state power levels\n"]
1141 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1142 #[repr(u8)]
1143 pub enum ExecutionStateLevel {
1144 Inactive = 0,
1145 Suspending = 1,
1146 Active = 2,
1147 UnknownOrdinal_(u8) = 3,
1148 }
1149 impl ::std::convert::From<u8> for ExecutionStateLevel {
1150 fn from(value: u8) -> Self {
1151 match value {
1152 0 => Self::Inactive,
1153 1 => Self::Suspending,
1154 2 => Self::Active,
1155
1156 _ => Self::UnknownOrdinal_(value),
1157 }
1158 }
1159 }
1160
1161 impl ::std::convert::From<ExecutionStateLevel> for u8 {
1162 fn from(value: ExecutionStateLevel) -> Self {
1163 match value {
1164 ExecutionStateLevel::Inactive => 0,
1165 ExecutionStateLevel::Suspending => 1,
1166 ExecutionStateLevel::Active => 2,
1167
1168 ExecutionStateLevel::UnknownOrdinal_(value) => value,
1169 }
1170 }
1171 }
1172
1173 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExecutionStateLevel, ___E>
1174 for ExecutionStateLevel
1175 where
1176 ___E: ?Sized,
1177 {
1178 #[inline]
1179 fn encode(
1180 self,
1181 encoder: &mut ___E,
1182 out: &mut ::core::mem::MaybeUninit<crate::wire::ExecutionStateLevel>,
1183 _: (),
1184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1185 ::fidl_next::Encode::encode(&self, encoder, out, ())
1186 }
1187 }
1188
1189 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExecutionStateLevel, ___E>
1190 for &'a ExecutionStateLevel
1191 where
1192 ___E: ?Sized,
1193 {
1194 #[inline]
1195 fn encode(
1196 self,
1197 encoder: &mut ___E,
1198 out: &mut ::core::mem::MaybeUninit<crate::wire::ExecutionStateLevel>,
1199 _: (),
1200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1201 ::fidl_next::munge!(let crate::wire::ExecutionStateLevel { value } = out);
1202 let _ = value.write(u8::from(match *self {
1203 ExecutionStateLevel::Inactive => 0,
1204
1205 ExecutionStateLevel::Suspending => 1,
1206
1207 ExecutionStateLevel::Active => 2,
1208
1209 ExecutionStateLevel::UnknownOrdinal_(value) => value,
1210 }));
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl ::core::convert::From<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
1217 fn from(wire: crate::wire::ExecutionStateLevel) -> Self {
1218 match u8::from(wire.value) {
1219 0 => Self::Inactive,
1220
1221 1 => Self::Suspending,
1222
1223 2 => Self::Active,
1224
1225 value => Self::UnknownOrdinal_(value),
1226 }
1227 }
1228 }
1229
1230 impl ::fidl_next::FromWire<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
1231 #[inline]
1232 fn from_wire(wire: crate::wire::ExecutionStateLevel) -> Self {
1233 Self::from(wire)
1234 }
1235 }
1236
1237 impl ::fidl_next::FromWireRef<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
1238 #[inline]
1239 fn from_wire_ref(wire: &crate::wire::ExecutionStateLevel) -> Self {
1240 Self::from(*wire)
1241 }
1242 }
1243
1244 pub type ExecutionStateManagerAddApplicationActivityDependencyResponse = ();
1245
1246 pub type SuspendBlockerBeforeSuspendResponse = ();
1247
1248 pub type SuspendBlockerAfterResumeResponse = ();
1249}
1250
1251pub mod wire {
1252
1253 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1255 #[repr(transparent)]
1256 pub struct AcquireWakeLeaseError {
1257 pub(crate) value: ::fidl_next::wire::Uint32,
1258 }
1259
1260 impl ::fidl_next::Constrained for AcquireWakeLeaseError {
1261 type Constraint = ();
1262
1263 fn validate(
1264 _: ::fidl_next::Slot<'_, Self>,
1265 _: Self::Constraint,
1266 ) -> Result<(), ::fidl_next::ValidationError> {
1267 Ok(())
1268 }
1269 }
1270
1271 unsafe impl ::fidl_next::Wire for AcquireWakeLeaseError {
1272 type Narrowed<'de> = Self;
1273
1274 #[inline]
1275 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1276 }
1278 }
1279
1280 impl AcquireWakeLeaseError {
1281 pub const INTERNAL: AcquireWakeLeaseError =
1282 AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(1) };
1283
1284 pub const INVALID_NAME: AcquireWakeLeaseError =
1285 AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(2) };
1286
1287 pub const SERVER_TOKEN_REQUIRED: AcquireWakeLeaseError =
1288 AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(3) };
1289
1290 pub const INVALID_PREVIOUS_TOKEN: AcquireWakeLeaseError =
1291 AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(4) };
1292 }
1293
1294 unsafe impl<___D> ::fidl_next::Decode<___D> for AcquireWakeLeaseError
1295 where
1296 ___D: ?Sized,
1297 {
1298 fn decode(
1299 slot: ::fidl_next::Slot<'_, Self>,
1300 _: &mut ___D,
1301 _: (),
1302 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1303 Ok(())
1304 }
1305 }
1306
1307 impl ::core::convert::From<crate::natural::AcquireWakeLeaseError> for AcquireWakeLeaseError {
1308 fn from(natural: crate::natural::AcquireWakeLeaseError) -> Self {
1309 match natural {
1310 crate::natural::AcquireWakeLeaseError::Internal => AcquireWakeLeaseError::INTERNAL,
1311
1312 crate::natural::AcquireWakeLeaseError::InvalidName => {
1313 AcquireWakeLeaseError::INVALID_NAME
1314 }
1315
1316 crate::natural::AcquireWakeLeaseError::ServerTokenRequired => {
1317 AcquireWakeLeaseError::SERVER_TOKEN_REQUIRED
1318 }
1319
1320 crate::natural::AcquireWakeLeaseError::InvalidPreviousToken => {
1321 AcquireWakeLeaseError::INVALID_PREVIOUS_TOKEN
1322 }
1323
1324 crate::natural::AcquireWakeLeaseError::UnknownOrdinal_(value) => {
1325 AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32::from(value) }
1326 }
1327 }
1328 }
1329 }
1330
1331 impl ::fidl_next::IntoNatural for AcquireWakeLeaseError {
1332 type Natural = crate::natural::AcquireWakeLeaseError;
1333 }
1334
1335 #[derive(Debug)]
1337 #[repr(C)]
1338 pub struct ActivityGovernorAcquireWakeLeaseRequest<'de> {
1339 pub name: ::fidl_next::wire::String<'de>,
1340 }
1341
1342 static_assertions::const_assert_eq!(
1343 std::mem::size_of::<ActivityGovernorAcquireWakeLeaseRequest<'_>>(),
1344 16
1345 );
1346 static_assertions::const_assert_eq!(
1347 std::mem::align_of::<ActivityGovernorAcquireWakeLeaseRequest<'_>>(),
1348 8
1349 );
1350
1351 static_assertions::const_assert_eq!(
1352 std::mem::offset_of!(ActivityGovernorAcquireWakeLeaseRequest<'_>, name),
1353 0
1354 );
1355
1356 impl ::fidl_next::Constrained for ActivityGovernorAcquireWakeLeaseRequest<'_> {
1357 type Constraint = ();
1358
1359 fn validate(
1360 _: ::fidl_next::Slot<'_, Self>,
1361 _: Self::Constraint,
1362 ) -> Result<(), ::fidl_next::ValidationError> {
1363 Ok(())
1364 }
1365 }
1366
1367 unsafe impl ::fidl_next::Wire for ActivityGovernorAcquireWakeLeaseRequest<'static> {
1368 type Narrowed<'de> = ActivityGovernorAcquireWakeLeaseRequest<'de>;
1369
1370 #[inline]
1371 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1372 ::fidl_next::munge! {
1373 let Self {
1374 name,
1375
1376 } = &mut *out_;
1377 }
1378
1379 ::fidl_next::Wire::zero_padding(name);
1380 }
1381 }
1382
1383 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ActivityGovernorAcquireWakeLeaseRequest<'de>
1384 where
1385 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1386 ___D: ::fidl_next::Decoder<'de>,
1387 {
1388 fn decode(
1389 slot_: ::fidl_next::Slot<'_, Self>,
1390 decoder_: &mut ___D,
1391 _: (),
1392 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1393 ::fidl_next::munge! {
1394 let Self {
1395 mut name,
1396
1397 } = slot_;
1398 }
1399
1400 let _field = name.as_mut();
1401 ::fidl_next::Constrained::validate(_field, 64)?;
1402 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 64)?;
1403
1404 let name = unsafe { name.deref_unchecked() };
1405
1406 if name.len() > 64 {
1407 return Err(::fidl_next::DecodeError::VectorTooLong {
1408 size: name.len() as u64,
1409 limit: 64,
1410 });
1411 }
1412
1413 Ok(())
1414 }
1415 }
1416
1417 impl<'de> ::fidl_next::IntoNatural for ActivityGovernorAcquireWakeLeaseRequest<'de> {
1418 type Natural = crate::natural::ActivityGovernorAcquireWakeLeaseRequest;
1419 }
1420
1421 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1423 #[repr(transparent)]
1424 pub struct RegisterSuspendBlockerError {
1425 pub(crate) value: ::fidl_next::wire::Uint32,
1426 }
1427
1428 impl ::fidl_next::Constrained for RegisterSuspendBlockerError {
1429 type Constraint = ();
1430
1431 fn validate(
1432 _: ::fidl_next::Slot<'_, Self>,
1433 _: Self::Constraint,
1434 ) -> Result<(), ::fidl_next::ValidationError> {
1435 Ok(())
1436 }
1437 }
1438
1439 unsafe impl ::fidl_next::Wire for RegisterSuspendBlockerError {
1440 type Narrowed<'de> = Self;
1441
1442 #[inline]
1443 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1444 }
1446 }
1447
1448 impl RegisterSuspendBlockerError {
1449 pub const INTERNAL: RegisterSuspendBlockerError =
1450 RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32(1) };
1451
1452 pub const INVALID_ARGS: RegisterSuspendBlockerError =
1453 RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32(2) };
1454 }
1455
1456 unsafe impl<___D> ::fidl_next::Decode<___D> for RegisterSuspendBlockerError
1457 where
1458 ___D: ?Sized,
1459 {
1460 fn decode(
1461 slot: ::fidl_next::Slot<'_, Self>,
1462 _: &mut ___D,
1463 _: (),
1464 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1465 Ok(())
1466 }
1467 }
1468
1469 impl ::core::convert::From<crate::natural::RegisterSuspendBlockerError>
1470 for RegisterSuspendBlockerError
1471 {
1472 fn from(natural: crate::natural::RegisterSuspendBlockerError) -> Self {
1473 match natural {
1474 crate::natural::RegisterSuspendBlockerError::Internal => {
1475 RegisterSuspendBlockerError::INTERNAL
1476 }
1477
1478 crate::natural::RegisterSuspendBlockerError::InvalidArgs => {
1479 RegisterSuspendBlockerError::INVALID_ARGS
1480 }
1481
1482 crate::natural::RegisterSuspendBlockerError::UnknownOrdinal_(value) => {
1483 RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32::from(value) }
1484 }
1485 }
1486 }
1487 }
1488
1489 impl ::fidl_next::IntoNatural for RegisterSuspendBlockerError {
1490 type Natural = crate::natural::RegisterSuspendBlockerError;
1491 }
1492
1493 #[derive(Debug)]
1495 #[repr(C)]
1496 pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de> {
1497 pub name: ::fidl_next::wire::String<'de>,
1498 }
1499
1500 static_assertions::const_assert_eq!(
1501 std::mem::size_of::<ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'_>>(),
1502 16
1503 );
1504 static_assertions::const_assert_eq!(
1505 std::mem::align_of::<ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'_>>(),
1506 8
1507 );
1508
1509 static_assertions::const_assert_eq!(
1510 std::mem::offset_of!(ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'_>, name),
1511 0
1512 );
1513
1514 impl ::fidl_next::Constrained for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'_> {
1515 type Constraint = ();
1516
1517 fn validate(
1518 _: ::fidl_next::Slot<'_, Self>,
1519 _: Self::Constraint,
1520 ) -> Result<(), ::fidl_next::ValidationError> {
1521 Ok(())
1522 }
1523 }
1524
1525 unsafe impl ::fidl_next::Wire for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static> {
1526 type Narrowed<'de> = ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>;
1527
1528 #[inline]
1529 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1530 ::fidl_next::munge! {
1531 let Self {
1532 name,
1533
1534 } = &mut *out_;
1535 }
1536
1537 ::fidl_next::Wire::zero_padding(name);
1538 }
1539 }
1540
1541 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
1542 for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>
1543 where
1544 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1545 ___D: ::fidl_next::Decoder<'de>,
1546 {
1547 fn decode(
1548 slot_: ::fidl_next::Slot<'_, Self>,
1549 decoder_: &mut ___D,
1550 _: (),
1551 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1552 ::fidl_next::munge! {
1553 let Self {
1554 mut name,
1555
1556 } = slot_;
1557 }
1558
1559 let _field = name.as_mut();
1560 ::fidl_next::Constrained::validate(_field, 64)?;
1561 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 64)?;
1562
1563 let name = unsafe { name.deref_unchecked() };
1564
1565 if name.len() > 64 {
1566 return Err(::fidl_next::DecodeError::VectorTooLong {
1567 size: name.len() as u64,
1568 limit: 64,
1569 });
1570 }
1571
1572 Ok(())
1573 }
1574 }
1575
1576 impl<'de> ::fidl_next::IntoNatural for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de> {
1577 type Natural = crate::natural::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest;
1578 }
1579
1580 pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ::fidl_next::wire::Unit;
1582
1583 pub type ActivityGovernorAcquireWakeLease2Response = ::fidl_next::wire::Unit;
1585
1586 #[derive(Debug)]
1588 #[repr(C)]
1589 pub struct ActivityGovernorTakeApplicationActivityLeaseRequest<'de> {
1590 pub name: ::fidl_next::wire::String<'de>,
1591 }
1592
1593 static_assertions::const_assert_eq!(
1594 std::mem::size_of::<ActivityGovernorTakeApplicationActivityLeaseRequest<'_>>(),
1595 16
1596 );
1597 static_assertions::const_assert_eq!(
1598 std::mem::align_of::<ActivityGovernorTakeApplicationActivityLeaseRequest<'_>>(),
1599 8
1600 );
1601
1602 static_assertions::const_assert_eq!(
1603 std::mem::offset_of!(ActivityGovernorTakeApplicationActivityLeaseRequest<'_>, name),
1604 0
1605 );
1606
1607 impl ::fidl_next::Constrained for ActivityGovernorTakeApplicationActivityLeaseRequest<'_> {
1608 type Constraint = ();
1609
1610 fn validate(
1611 _: ::fidl_next::Slot<'_, Self>,
1612 _: Self::Constraint,
1613 ) -> Result<(), ::fidl_next::ValidationError> {
1614 Ok(())
1615 }
1616 }
1617
1618 unsafe impl ::fidl_next::Wire for ActivityGovernorTakeApplicationActivityLeaseRequest<'static> {
1619 type Narrowed<'de> = ActivityGovernorTakeApplicationActivityLeaseRequest<'de>;
1620
1621 #[inline]
1622 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1623 ::fidl_next::munge! {
1624 let Self {
1625 name,
1626
1627 } = &mut *out_;
1628 }
1629
1630 ::fidl_next::Wire::zero_padding(name);
1631 }
1632 }
1633
1634 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
1635 for ActivityGovernorTakeApplicationActivityLeaseRequest<'de>
1636 where
1637 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1638 ___D: ::fidl_next::Decoder<'de>,
1639 {
1640 fn decode(
1641 slot_: ::fidl_next::Slot<'_, Self>,
1642 decoder_: &mut ___D,
1643 _: (),
1644 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1645 ::fidl_next::munge! {
1646 let Self {
1647 mut name,
1648
1649 } = slot_;
1650 }
1651
1652 let _field = name.as_mut();
1653 ::fidl_next::Constrained::validate(_field, 64)?;
1654 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 64)?;
1655
1656 let name = unsafe { name.deref_unchecked() };
1657
1658 if name.len() > 64 {
1659 return Err(::fidl_next::DecodeError::VectorTooLong {
1660 size: name.len() as u64,
1661 limit: 64,
1662 });
1663 }
1664
1665 Ok(())
1666 }
1667 }
1668
1669 impl<'de> ::fidl_next::IntoNatural for ActivityGovernorTakeApplicationActivityLeaseRequest<'de> {
1670 type Natural = crate::natural::ActivityGovernorTakeApplicationActivityLeaseRequest;
1671 }
1672
1673 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1675 #[repr(transparent)]
1676 pub struct AddApplicationActivityDependencyError {
1677 pub(crate) value: ::fidl_next::wire::Uint32,
1678 }
1679
1680 impl ::fidl_next::Constrained for AddApplicationActivityDependencyError {
1681 type Constraint = ();
1682
1683 fn validate(
1684 _: ::fidl_next::Slot<'_, Self>,
1685 _: Self::Constraint,
1686 ) -> Result<(), ::fidl_next::ValidationError> {
1687 Ok(())
1688 }
1689 }
1690
1691 unsafe impl ::fidl_next::Wire for AddApplicationActivityDependencyError {
1692 type Narrowed<'de> = Self;
1693
1694 #[inline]
1695 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1696 }
1698 }
1699
1700 impl AddApplicationActivityDependencyError {
1701 pub const ALREADY_EXISTS: AddApplicationActivityDependencyError =
1702 AddApplicationActivityDependencyError { value: ::fidl_next::wire::Uint32(1) };
1703
1704 pub const INVALID: AddApplicationActivityDependencyError =
1705 AddApplicationActivityDependencyError { value: ::fidl_next::wire::Uint32(2) };
1706
1707 pub const INTERNAL: AddApplicationActivityDependencyError =
1708 AddApplicationActivityDependencyError { value: ::fidl_next::wire::Uint32(3) };
1709 }
1710
1711 unsafe impl<___D> ::fidl_next::Decode<___D> for AddApplicationActivityDependencyError
1712 where
1713 ___D: ?Sized,
1714 {
1715 fn decode(
1716 slot: ::fidl_next::Slot<'_, Self>,
1717 _: &mut ___D,
1718 _: (),
1719 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1720 Ok(())
1721 }
1722 }
1723
1724 impl ::core::convert::From<crate::natural::AddApplicationActivityDependencyError>
1725 for AddApplicationActivityDependencyError
1726 {
1727 fn from(natural: crate::natural::AddApplicationActivityDependencyError) -> Self {
1728 match natural {
1729 crate::natural::AddApplicationActivityDependencyError::AlreadyExists => {
1730 AddApplicationActivityDependencyError::ALREADY_EXISTS
1731 }
1732
1733 crate::natural::AddApplicationActivityDependencyError::Invalid => {
1734 AddApplicationActivityDependencyError::INVALID
1735 }
1736
1737 crate::natural::AddApplicationActivityDependencyError::Internal => {
1738 AddApplicationActivityDependencyError::INTERNAL
1739 }
1740
1741 crate::natural::AddApplicationActivityDependencyError::UnknownOrdinal_(value) => {
1742 AddApplicationActivityDependencyError {
1743 value: ::fidl_next::wire::Uint32::from(value),
1744 }
1745 }
1746 }
1747 }
1748 }
1749
1750 impl ::fidl_next::IntoNatural for AddApplicationActivityDependencyError {
1751 type Natural = crate::natural::AddApplicationActivityDependencyError;
1752 }
1753
1754 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1756 #[repr(transparent)]
1757 pub struct AddExecutionStateDependencyError {
1758 pub(crate) value: ::fidl_next::wire::Uint32,
1759 }
1760
1761 impl ::fidl_next::Constrained for AddExecutionStateDependencyError {
1762 type Constraint = ();
1763
1764 fn validate(
1765 _: ::fidl_next::Slot<'_, Self>,
1766 _: Self::Constraint,
1767 ) -> Result<(), ::fidl_next::ValidationError> {
1768 Ok(())
1769 }
1770 }
1771
1772 unsafe impl ::fidl_next::Wire for AddExecutionStateDependencyError {
1773 type Narrowed<'de> = Self;
1774
1775 #[inline]
1776 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1777 }
1779 }
1780
1781 impl AddExecutionStateDependencyError {
1782 pub const INVALID_ARGS: AddExecutionStateDependencyError =
1783 AddExecutionStateDependencyError { value: ::fidl_next::wire::Uint32(1) };
1784
1785 pub const BAD_STATE: AddExecutionStateDependencyError =
1786 AddExecutionStateDependencyError { value: ::fidl_next::wire::Uint32(2) };
1787 }
1788
1789 unsafe impl<___D> ::fidl_next::Decode<___D> for AddExecutionStateDependencyError
1790 where
1791 ___D: ?Sized,
1792 {
1793 fn decode(
1794 slot: ::fidl_next::Slot<'_, Self>,
1795 _: &mut ___D,
1796 _: (),
1797 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1798 Ok(())
1799 }
1800 }
1801
1802 impl ::core::convert::From<crate::natural::AddExecutionStateDependencyError>
1803 for AddExecutionStateDependencyError
1804 {
1805 fn from(natural: crate::natural::AddExecutionStateDependencyError) -> Self {
1806 match natural {
1807 crate::natural::AddExecutionStateDependencyError::InvalidArgs => {
1808 AddExecutionStateDependencyError::INVALID_ARGS
1809 }
1810
1811 crate::natural::AddExecutionStateDependencyError::BadState => {
1812 AddExecutionStateDependencyError::BAD_STATE
1813 }
1814
1815 crate::natural::AddExecutionStateDependencyError::UnknownOrdinal_(value) => {
1816 AddExecutionStateDependencyError {
1817 value: ::fidl_next::wire::Uint32::from(value),
1818 }
1819 }
1820 }
1821 }
1822 }
1823
1824 impl ::fidl_next::IntoNatural for AddExecutionStateDependencyError {
1825 type Natural = crate::natural::AddExecutionStateDependencyError;
1826 }
1827
1828 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1830 #[repr(transparent)]
1831 pub struct ApplicationActivityLevel {
1832 pub(crate) value: u8,
1833 }
1834
1835 impl ::fidl_next::Constrained for ApplicationActivityLevel {
1836 type Constraint = ();
1837
1838 fn validate(
1839 _: ::fidl_next::Slot<'_, Self>,
1840 _: Self::Constraint,
1841 ) -> Result<(), ::fidl_next::ValidationError> {
1842 Ok(())
1843 }
1844 }
1845
1846 unsafe impl ::fidl_next::Wire for ApplicationActivityLevel {
1847 type Narrowed<'de> = Self;
1848
1849 #[inline]
1850 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1851 }
1853 }
1854
1855 impl ApplicationActivityLevel {
1856 pub const INACTIVE: ApplicationActivityLevel = ApplicationActivityLevel { value: 0 };
1857
1858 pub const ACTIVE: ApplicationActivityLevel = ApplicationActivityLevel { value: 1 };
1859 }
1860
1861 unsafe impl<___D> ::fidl_next::Decode<___D> for ApplicationActivityLevel
1862 where
1863 ___D: ?Sized,
1864 {
1865 fn decode(
1866 slot: ::fidl_next::Slot<'_, Self>,
1867 _: &mut ___D,
1868 _: (),
1869 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1870 Ok(())
1871 }
1872 }
1873
1874 impl ::core::convert::From<crate::natural::ApplicationActivityLevel> for ApplicationActivityLevel {
1875 fn from(natural: crate::natural::ApplicationActivityLevel) -> Self {
1876 match natural {
1877 crate::natural::ApplicationActivityLevel::Inactive => {
1878 ApplicationActivityLevel::INACTIVE
1879 }
1880
1881 crate::natural::ApplicationActivityLevel::Active => {
1882 ApplicationActivityLevel::ACTIVE
1883 }
1884
1885 crate::natural::ApplicationActivityLevel::UnknownOrdinal_(value) => {
1886 ApplicationActivityLevel { value: u8::from(value) }
1887 }
1888 }
1889 }
1890 }
1891
1892 impl ::fidl_next::IntoNatural for ApplicationActivityLevel {
1893 type Natural = crate::natural::ApplicationActivityLevel;
1894 }
1895
1896 pub type BootControlSetBootCompleteResponse = ::fidl_next::wire::Unit;
1898
1899 pub type CpuElementManagerAddExecutionStateDependencyResponse = ::fidl_next::wire::Unit;
1901
1902 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1904 #[repr(transparent)]
1905 pub struct CpuLevel {
1906 pub(crate) value: u8,
1907 }
1908
1909 impl ::fidl_next::Constrained for CpuLevel {
1910 type Constraint = ();
1911
1912 fn validate(
1913 _: ::fidl_next::Slot<'_, Self>,
1914 _: Self::Constraint,
1915 ) -> Result<(), ::fidl_next::ValidationError> {
1916 Ok(())
1917 }
1918 }
1919
1920 unsafe impl ::fidl_next::Wire for CpuLevel {
1921 type Narrowed<'de> = Self;
1922
1923 #[inline]
1924 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1925 }
1927 }
1928
1929 impl CpuLevel {
1930 pub const INACTIVE: CpuLevel = CpuLevel { value: 0 };
1931
1932 pub const ACTIVE: CpuLevel = CpuLevel { value: 1 };
1933 }
1934
1935 unsafe impl<___D> ::fidl_next::Decode<___D> for CpuLevel
1936 where
1937 ___D: ?Sized,
1938 {
1939 fn decode(
1940 slot: ::fidl_next::Slot<'_, Self>,
1941 _: &mut ___D,
1942 _: (),
1943 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1944 Ok(())
1945 }
1946 }
1947
1948 impl ::core::convert::From<crate::natural::CpuLevel> for CpuLevel {
1949 fn from(natural: crate::natural::CpuLevel) -> Self {
1950 match natural {
1951 crate::natural::CpuLevel::Inactive => CpuLevel::INACTIVE,
1952
1953 crate::natural::CpuLevel::Active => CpuLevel::ACTIVE,
1954
1955 crate::natural::CpuLevel::UnknownOrdinal_(value) => {
1956 CpuLevel { value: u8::from(value) }
1957 }
1958 }
1959 }
1960 }
1961
1962 impl ::fidl_next::IntoNatural for CpuLevel {
1963 type Natural = crate::natural::CpuLevel;
1964 }
1965
1966 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1968 #[repr(transparent)]
1969 pub struct ExecutionStateLevel {
1970 pub(crate) value: u8,
1971 }
1972
1973 impl ::fidl_next::Constrained for ExecutionStateLevel {
1974 type Constraint = ();
1975
1976 fn validate(
1977 _: ::fidl_next::Slot<'_, Self>,
1978 _: Self::Constraint,
1979 ) -> Result<(), ::fidl_next::ValidationError> {
1980 Ok(())
1981 }
1982 }
1983
1984 unsafe impl ::fidl_next::Wire for ExecutionStateLevel {
1985 type Narrowed<'de> = Self;
1986
1987 #[inline]
1988 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
1989 }
1991 }
1992
1993 impl ExecutionStateLevel {
1994 pub const INACTIVE: ExecutionStateLevel = ExecutionStateLevel { value: 0 };
1995
1996 pub const SUSPENDING: ExecutionStateLevel = ExecutionStateLevel { value: 1 };
1997
1998 pub const ACTIVE: ExecutionStateLevel = ExecutionStateLevel { value: 2 };
1999 }
2000
2001 unsafe impl<___D> ::fidl_next::Decode<___D> for ExecutionStateLevel
2002 where
2003 ___D: ?Sized,
2004 {
2005 fn decode(
2006 slot: ::fidl_next::Slot<'_, Self>,
2007 _: &mut ___D,
2008 _: (),
2009 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2010 Ok(())
2011 }
2012 }
2013
2014 impl ::core::convert::From<crate::natural::ExecutionStateLevel> for ExecutionStateLevel {
2015 fn from(natural: crate::natural::ExecutionStateLevel) -> Self {
2016 match natural {
2017 crate::natural::ExecutionStateLevel::Inactive => ExecutionStateLevel::INACTIVE,
2018
2019 crate::natural::ExecutionStateLevel::Suspending => ExecutionStateLevel::SUSPENDING,
2020
2021 crate::natural::ExecutionStateLevel::Active => ExecutionStateLevel::ACTIVE,
2022
2023 crate::natural::ExecutionStateLevel::UnknownOrdinal_(value) => {
2024 ExecutionStateLevel { value: u8::from(value) }
2025 }
2026 }
2027 }
2028 }
2029
2030 impl ::fidl_next::IntoNatural for ExecutionStateLevel {
2031 type Natural = crate::natural::ExecutionStateLevel;
2032 }
2033
2034 pub type ExecutionStateManagerAddApplicationActivityDependencyResponse =
2036 ::fidl_next::wire::Unit;
2037
2038 pub type SuspendBlockerBeforeSuspendResponse = ::fidl_next::wire::Unit;
2040
2041 pub type SuspendBlockerAfterResumeResponse = ::fidl_next::wire::Unit;
2043}
2044
2045pub mod wire_optional {}
2046
2047pub mod generic {
2048
2049 pub struct ActivityGovernorAcquireWakeLeaseRequest<T0> {
2051 pub name: T0,
2052 }
2053
2054 unsafe impl<___E, T0>
2055 ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>
2056 for ActivityGovernorAcquireWakeLeaseRequest<T0>
2057 where
2058 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2059 ___E: ::fidl_next::Encoder,
2060 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2061 {
2062 #[inline]
2063 fn encode(
2064 self,
2065 encoder_: &mut ___E,
2066 out_: &mut ::core::mem::MaybeUninit<
2067 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
2068 >,
2069 _: (),
2070 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2071 ::fidl_next::munge! {
2072 let crate::wire::ActivityGovernorAcquireWakeLeaseRequest {
2073 name,
2074
2075 } = out_;
2076 }
2077
2078 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
2079
2080 Ok(())
2081 }
2082 }
2083
2084 unsafe impl<'a, ___E, T0>
2085 ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>, ___E>
2086 for &'a ActivityGovernorAcquireWakeLeaseRequest<T0>
2087 where
2088 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2089 ___E: ::fidl_next::Encoder,
2090 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2091 {
2092 #[inline]
2093 fn encode(
2094 self,
2095 encoder_: &mut ___E,
2096 out_: &mut ::core::mem::MaybeUninit<
2097 crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
2098 >,
2099 _: (),
2100 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2101 ::fidl_next::munge! {
2102 let crate::wire::ActivityGovernorAcquireWakeLeaseRequest {
2103 name,
2104
2105 } = out_;
2106 }
2107
2108 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
2109
2110 Ok(())
2111 }
2112 }
2113
2114 pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<T0> {
2116 pub name: T0,
2117 }
2118
2119 unsafe impl<___E, T0>
2120 ::fidl_next::Encode<
2121 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
2122 ___E,
2123 > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<T0>
2124 where
2125 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2126 ___E: ::fidl_next::Encoder,
2127 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2128 {
2129 #[inline]
2130 fn encode(
2131 self,
2132 encoder_: &mut ___E,
2133 out_: &mut ::core::mem::MaybeUninit<
2134 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
2135 >,
2136 _: (),
2137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2138 ::fidl_next::munge! {
2139 let crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
2140 name,
2141
2142 } = out_;
2143 }
2144
2145 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
2146
2147 Ok(())
2148 }
2149 }
2150
2151 unsafe impl<'a, ___E, T0>
2152 ::fidl_next::Encode<
2153 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
2154 ___E,
2155 > for &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<T0>
2156 where
2157 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2158 ___E: ::fidl_next::Encoder,
2159 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2160 {
2161 #[inline]
2162 fn encode(
2163 self,
2164 encoder_: &mut ___E,
2165 out_: &mut ::core::mem::MaybeUninit<
2166 crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
2167 >,
2168 _: (),
2169 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2170 ::fidl_next::munge! {
2171 let crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
2172 name,
2173
2174 } = out_;
2175 }
2176
2177 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
2178
2179 Ok(())
2180 }
2181 }
2182
2183 pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ();
2185
2186 pub type ActivityGovernorAcquireWakeLease2Response = ();
2188
2189 pub struct ActivityGovernorTakeApplicationActivityLeaseRequest<T0> {
2191 pub name: T0,
2192 }
2193
2194 unsafe impl<___E, T0>
2195 ::fidl_next::Encode<
2196 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
2197 ___E,
2198 > for ActivityGovernorTakeApplicationActivityLeaseRequest<T0>
2199 where
2200 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2201 ___E: ::fidl_next::Encoder,
2202 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2203 {
2204 #[inline]
2205 fn encode(
2206 self,
2207 encoder_: &mut ___E,
2208 out_: &mut ::core::mem::MaybeUninit<
2209 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
2210 >,
2211 _: (),
2212 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2213 ::fidl_next::munge! {
2214 let crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest {
2215 name,
2216
2217 } = out_;
2218 }
2219
2220 ::fidl_next::Encode::encode(self.name, encoder_, name, 64)?;
2221
2222 Ok(())
2223 }
2224 }
2225
2226 unsafe impl<'a, ___E, T0>
2227 ::fidl_next::Encode<
2228 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
2229 ___E,
2230 > for &'a ActivityGovernorTakeApplicationActivityLeaseRequest<T0>
2231 where
2232 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2233 ___E: ::fidl_next::Encoder,
2234 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
2235 {
2236 #[inline]
2237 fn encode(
2238 self,
2239 encoder_: &mut ___E,
2240 out_: &mut ::core::mem::MaybeUninit<
2241 crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
2242 >,
2243 _: (),
2244 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2245 ::fidl_next::munge! {
2246 let crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest {
2247 name,
2248
2249 } = out_;
2250 }
2251
2252 ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;
2253
2254 Ok(())
2255 }
2256 }
2257
2258 pub type BootControlSetBootCompleteResponse = ();
2260
2261 pub type CpuElementManagerAddExecutionStateDependencyResponse = ();
2263
2264 pub type ExecutionStateManagerAddApplicationActivityDependencyResponse = ();
2266
2267 pub type SuspendBlockerBeforeSuspendResponse = ();
2269
2270 pub type SuspendBlockerAfterResumeResponse = ();
2272}
2273
2274pub use self::natural::*;
2275
2276pub const MAX_ELEMENT_NAME_LEN: u8 = 64 as u8;
2277
2278#[doc = " A service that processes notification about the system boot state.\n"]
2280#[derive(PartialEq, Debug)]
2281pub struct BootControl;
2282
2283impl ::fidl_next::Discoverable for BootControl {
2284 const PROTOCOL_NAME: &'static str = "fuchsia.power.system.BootControl";
2285}
2286
2287#[cfg(target_os = "fuchsia")]
2288impl ::fidl_next::HasTransport for BootControl {
2289 type Transport = ::fidl_next::fuchsia::zx::Channel;
2290}
2291
2292pub mod boot_control {
2293 pub mod prelude {
2294 pub use crate::{
2295 BootControl, BootControlClientHandler, BootControlLocalClientHandler,
2296 BootControlLocalServerHandler, BootControlServerHandler, boot_control,
2297 };
2298
2299 pub use crate::natural::BootControlSetBootCompleteResponse;
2300 }
2301
2302 pub struct SetBootComplete;
2303
2304 impl ::fidl_next::Method for SetBootComplete {
2305 const ORDINAL: u64 = 4367259243539899061;
2306 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2307 ::fidl_next::protocol::Flexibility::Flexible;
2308
2309 type Protocol = crate::BootControl;
2310
2311 type Request = ::fidl_next::wire::EmptyMessageBody;
2312 }
2313
2314 impl ::fidl_next::TwoWayMethod for SetBootComplete {
2315 type Response =
2316 ::fidl_next::wire::Flexible<'static, crate::wire::BootControlSetBootCompleteResponse>;
2317 }
2318
2319 impl<___R> ::fidl_next::Respond<___R> for SetBootComplete {
2320 type Output = ::fidl_next::Flexible<___R>;
2321
2322 fn respond(response: ___R) -> Self::Output {
2323 ::fidl_next::Flexible(response)
2324 }
2325 }
2326
2327 mod ___detail {
2328 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::BootControl
2329 where
2330 ___T: ::fidl_next::Transport,
2331 {
2332 type Client = BootControlClient<___T>;
2333 type Server = BootControlServer<___T>;
2334 }
2335
2336 #[repr(transparent)]
2338 pub struct BootControlClient<___T: ::fidl_next::Transport> {
2339 #[allow(dead_code)]
2340 client: ::fidl_next::protocol::Client<___T>,
2341 }
2342
2343 impl<___T> BootControlClient<___T>
2344 where
2345 ___T: ::fidl_next::Transport,
2346 {
2347 #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
2348 pub fn set_boot_complete(
2349 &self,
2350 ) -> ::fidl_next::TwoWayFuture<'_, super::SetBootComplete, ___T> {
2351 ::fidl_next::TwoWayFuture::from_untyped(
2352 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
2353 4367259243539899061,
2354 <super::SetBootComplete as ::fidl_next::Method>::FLEXIBILITY,
2355 (),
2356 ),
2357 )
2358 }
2359 }
2360
2361 #[repr(transparent)]
2363 pub struct BootControlServer<___T: ::fidl_next::Transport> {
2364 server: ::fidl_next::protocol::Server<___T>,
2365 }
2366
2367 impl<___T> BootControlServer<___T> where ___T: ::fidl_next::Transport {}
2368 }
2369}
2370
2371#[diagnostic::on_unimplemented(
2372 note = "If {Self} implements the non-local BootControlClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
2373)]
2374
2375pub trait BootControlLocalClientHandler<
2379 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2380 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2381>
2382{
2383 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
2384 ::core::future::ready(())
2385 }
2386}
2387
2388impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for BootControl
2389where
2390 ___H: BootControlLocalClientHandler<___T>,
2391 ___T: ::fidl_next::Transport,
2392{
2393 async fn on_event(
2394 handler: &mut ___H,
2395 mut message: ::fidl_next::Message<___T>,
2396 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2397 match *message.header().ordinal {
2398 ordinal => {
2399 handler.on_unknown_interaction(ordinal).await;
2400 if ::core::matches!(
2401 message.header().flexibility(),
2402 ::fidl_next::protocol::Flexibility::Strict
2403 ) {
2404 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2405 } else {
2406 Ok(())
2407 }
2408 }
2409 }
2410 }
2411}
2412
2413#[diagnostic::on_unimplemented(
2414 note = "If {Self} implements the non-local BootControlServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
2415)]
2416
2417pub trait BootControlLocalServerHandler<
2421 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2422 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2423>
2424{
2425 #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
2426 fn set_boot_complete(
2427 &mut self,
2428
2429 responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___T>,
2430 ) -> impl ::core::future::Future<Output = ()>;
2431
2432 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
2433 ::core::future::ready(())
2434 }
2435}
2436
2437impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for BootControl
2438where
2439 ___H: BootControlLocalServerHandler<___T>,
2440 ___T: ::fidl_next::Transport,
2441{
2442 async fn on_one_way(
2443 handler: &mut ___H,
2444 mut message: ::fidl_next::Message<___T>,
2445 ) -> ::core::result::Result<
2446 (),
2447 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2448 > {
2449 match *message.header().ordinal {
2450 ordinal => {
2451 handler.on_unknown_interaction(ordinal).await;
2452 if ::core::matches!(
2453 message.header().flexibility(),
2454 ::fidl_next::protocol::Flexibility::Strict
2455 ) {
2456 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2457 } else {
2458 Ok(())
2459 }
2460 }
2461 }
2462 }
2463
2464 async fn on_two_way(
2465 handler: &mut ___H,
2466 mut message: ::fidl_next::Message<___T>,
2467 responder: ::fidl_next::protocol::Responder<___T>,
2468 ) -> ::core::result::Result<
2469 (),
2470 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2471 > {
2472 match *message.header().ordinal {
2473 4367259243539899061 => {
2474 let responder = ::fidl_next::Responder::from_untyped(responder);
2475
2476 handler.set_boot_complete(responder).await;
2477 Ok(())
2478 }
2479
2480 ordinal => {
2481 handler.on_unknown_interaction(ordinal).await;
2482 if ::core::matches!(
2483 message.header().flexibility(),
2484 ::fidl_next::protocol::Flexibility::Strict
2485 ) {
2486 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2487 } else {
2488 responder
2489 .respond_framework_error(
2490 ordinal,
2491 ::fidl_next::FrameworkError::UnknownMethod,
2492 )
2493 .expect("encoding a framework error should never fail")
2494 .await?;
2495 Ok(())
2496 }
2497 }
2498 }
2499 }
2500}
2501
2502pub trait BootControlClientHandler<
2506 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2507 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2508>
2509{
2510 fn on_unknown_interaction(
2511 &mut self,
2512 ordinal: u64,
2513 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
2514 ::core::future::ready(())
2515 }
2516}
2517
2518impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for BootControl
2519where
2520 ___H: BootControlClientHandler<___T> + ::core::marker::Send,
2521 ___T: ::fidl_next::Transport,
2522{
2523 async fn on_event(
2524 handler: &mut ___H,
2525 mut message: ::fidl_next::Message<___T>,
2526 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2527 match *message.header().ordinal {
2528 ordinal => {
2529 handler.on_unknown_interaction(ordinal).await;
2530 if ::core::matches!(
2531 message.header().flexibility(),
2532 ::fidl_next::protocol::Flexibility::Strict
2533 ) {
2534 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2535 } else {
2536 Ok(())
2537 }
2538 }
2539 }
2540 }
2541}
2542
2543pub trait BootControlServerHandler<
2547 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2548 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2549>
2550{
2551 #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
2552 fn set_boot_complete(
2553 &mut self,
2554
2555 responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___T>,
2556 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
2557
2558 fn on_unknown_interaction(
2559 &mut self,
2560 ordinal: u64,
2561 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
2562 ::core::future::ready(())
2563 }
2564}
2565
2566impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for BootControl
2567where
2568 ___H: BootControlServerHandler<___T> + ::core::marker::Send,
2569 ___T: ::fidl_next::Transport,
2570{
2571 async fn on_one_way(
2572 handler: &mut ___H,
2573 mut message: ::fidl_next::Message<___T>,
2574 ) -> ::core::result::Result<
2575 (),
2576 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2577 > {
2578 match *message.header().ordinal {
2579 ordinal => {
2580 handler.on_unknown_interaction(ordinal).await;
2581 if ::core::matches!(
2582 message.header().flexibility(),
2583 ::fidl_next::protocol::Flexibility::Strict
2584 ) {
2585 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2586 } else {
2587 Ok(())
2588 }
2589 }
2590 }
2591 }
2592
2593 async fn on_two_way(
2594 handler: &mut ___H,
2595 mut message: ::fidl_next::Message<___T>,
2596 responder: ::fidl_next::protocol::Responder<___T>,
2597 ) -> ::core::result::Result<
2598 (),
2599 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2600 > {
2601 match *message.header().ordinal {
2602 4367259243539899061 => {
2603 let responder = ::fidl_next::Responder::from_untyped(responder);
2604
2605 handler.set_boot_complete(responder).await;
2606 Ok(())
2607 }
2608
2609 ordinal => {
2610 handler.on_unknown_interaction(ordinal).await;
2611 if ::core::matches!(
2612 message.header().flexibility(),
2613 ::fidl_next::protocol::Flexibility::Strict
2614 ) {
2615 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2616 } else {
2617 responder
2618 .respond_framework_error(
2619 ordinal,
2620 ::fidl_next::FrameworkError::UnknownMethod,
2621 )
2622 .expect("encoding a framework error should never fail")
2623 .await?;
2624 Ok(())
2625 }
2626 }
2627 }
2628 }
2629}
2630
2631impl<___T> BootControlClientHandler<___T> for ::fidl_next::IgnoreEvents
2632where
2633 ___T: ::fidl_next::Transport,
2634{
2635 async fn on_unknown_interaction(&mut self, _: u64) {}
2636}
2637
2638impl<___H, ___T> BootControlLocalClientHandler<___T> for ::fidl_next::Local<___H>
2639where
2640 ___H: BootControlClientHandler<___T>,
2641 ___T: ::fidl_next::Transport,
2642{
2643 async fn on_unknown_interaction(&mut self, ordinal: u64) {
2644 ___H::on_unknown_interaction(&mut self.0, ordinal).await
2645 }
2646}
2647
2648impl<___H, ___T> BootControlLocalServerHandler<___T> for ::fidl_next::Local<___H>
2649where
2650 ___H: BootControlServerHandler<___T>,
2651 ___T: ::fidl_next::Transport,
2652{
2653 async fn set_boot_complete(
2654 &mut self,
2655
2656 responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___T>,
2657 ) {
2658 ___H::set_boot_complete(&mut self.0, responder).await
2659 }
2660
2661 async fn on_unknown_interaction(&mut self, ordinal: u64) {
2662 ___H::on_unknown_interaction(&mut self.0, ordinal).await
2663 }
2664}
2665
2666#[doc = " An entity that blocks suspend until it handles transitions across hardware\n platform suspend and resume.\n"]
2668#[derive(PartialEq, Debug)]
2669pub struct SuspendBlocker;
2670
2671#[cfg(target_os = "fuchsia")]
2672impl ::fidl_next::HasTransport for SuspendBlocker {
2673 type Transport = ::fidl_next::fuchsia::zx::Channel;
2674}
2675
2676pub mod suspend_blocker {
2677 pub mod prelude {
2678 pub use crate::{
2679 SuspendBlocker, SuspendBlockerClientHandler, SuspendBlockerLocalClientHandler,
2680 SuspendBlockerLocalServerHandler, SuspendBlockerServerHandler, suspend_blocker,
2681 };
2682
2683 pub use crate::natural::SuspendBlockerAfterResumeResponse;
2684
2685 pub use crate::natural::SuspendBlockerBeforeSuspendResponse;
2686 }
2687
2688 pub struct BeforeSuspend;
2689
2690 impl ::fidl_next::Method for BeforeSuspend {
2691 const ORDINAL: u64 = 7734531672310967680;
2692 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2693 ::fidl_next::protocol::Flexibility::Flexible;
2694
2695 type Protocol = crate::SuspendBlocker;
2696
2697 type Request = ::fidl_next::wire::EmptyMessageBody;
2698 }
2699
2700 impl ::fidl_next::TwoWayMethod for BeforeSuspend {
2701 type Response =
2702 ::fidl_next::wire::Flexible<'static, crate::wire::SuspendBlockerBeforeSuspendResponse>;
2703 }
2704
2705 impl<___R> ::fidl_next::Respond<___R> for BeforeSuspend {
2706 type Output = ::fidl_next::Flexible<___R>;
2707
2708 fn respond(response: ___R) -> Self::Output {
2709 ::fidl_next::Flexible(response)
2710 }
2711 }
2712
2713 pub struct AfterResume;
2714
2715 impl ::fidl_next::Method for AfterResume {
2716 const ORDINAL: u64 = 7652351326344392170;
2717 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
2718 ::fidl_next::protocol::Flexibility::Flexible;
2719
2720 type Protocol = crate::SuspendBlocker;
2721
2722 type Request = ::fidl_next::wire::EmptyMessageBody;
2723 }
2724
2725 impl ::fidl_next::TwoWayMethod for AfterResume {
2726 type Response =
2727 ::fidl_next::wire::Flexible<'static, crate::wire::SuspendBlockerAfterResumeResponse>;
2728 }
2729
2730 impl<___R> ::fidl_next::Respond<___R> for AfterResume {
2731 type Output = ::fidl_next::Flexible<___R>;
2732
2733 fn respond(response: ___R) -> Self::Output {
2734 ::fidl_next::Flexible(response)
2735 }
2736 }
2737
2738 mod ___detail {
2739 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SuspendBlocker
2740 where
2741 ___T: ::fidl_next::Transport,
2742 {
2743 type Client = SuspendBlockerClient<___T>;
2744 type Server = SuspendBlockerServer<___T>;
2745 }
2746
2747 #[repr(transparent)]
2749 pub struct SuspendBlockerClient<___T: ::fidl_next::Transport> {
2750 #[allow(dead_code)]
2751 client: ::fidl_next::protocol::Client<___T>,
2752 }
2753
2754 impl<___T> SuspendBlockerClient<___T>
2755 where
2756 ___T: ::fidl_next::Transport,
2757 {
2758 #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2759 pub fn before_suspend(
2760 &self,
2761 ) -> ::fidl_next::TwoWayFuture<'_, super::BeforeSuspend, ___T> {
2762 ::fidl_next::TwoWayFuture::from_untyped(
2763 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
2764 7734531672310967680,
2765 <super::BeforeSuspend as ::fidl_next::Method>::FLEXIBILITY,
2766 (),
2767 ),
2768 )
2769 }
2770
2771 #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2772 pub fn after_resume(&self) -> ::fidl_next::TwoWayFuture<'_, super::AfterResume, ___T> {
2773 ::fidl_next::TwoWayFuture::from_untyped(
2774 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
2775 7652351326344392170,
2776 <super::AfterResume as ::fidl_next::Method>::FLEXIBILITY,
2777 (),
2778 ),
2779 )
2780 }
2781 }
2782
2783 #[repr(transparent)]
2785 pub struct SuspendBlockerServer<___T: ::fidl_next::Transport> {
2786 server: ::fidl_next::protocol::Server<___T>,
2787 }
2788
2789 impl<___T> SuspendBlockerServer<___T> where ___T: ::fidl_next::Transport {}
2790 }
2791}
2792
2793#[diagnostic::on_unimplemented(
2794 note = "If {Self} implements the non-local SuspendBlockerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
2795)]
2796
2797pub trait SuspendBlockerLocalClientHandler<
2801 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2802 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2803>
2804{
2805 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
2806 ::core::future::ready(())
2807 }
2808}
2809
2810impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for SuspendBlocker
2811where
2812 ___H: SuspendBlockerLocalClientHandler<___T>,
2813 ___T: ::fidl_next::Transport,
2814{
2815 async fn on_event(
2816 handler: &mut ___H,
2817 mut message: ::fidl_next::Message<___T>,
2818 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2819 match *message.header().ordinal {
2820 ordinal => {
2821 handler.on_unknown_interaction(ordinal).await;
2822 if ::core::matches!(
2823 message.header().flexibility(),
2824 ::fidl_next::protocol::Flexibility::Strict
2825 ) {
2826 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2827 } else {
2828 Ok(())
2829 }
2830 }
2831 }
2832 }
2833}
2834
2835#[diagnostic::on_unimplemented(
2836 note = "If {Self} implements the non-local SuspendBlockerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
2837)]
2838
2839pub trait SuspendBlockerLocalServerHandler<
2843 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2844 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2845>
2846{
2847 #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2848 fn before_suspend(
2849 &mut self,
2850
2851 responder: ::fidl_next::Responder<suspend_blocker::BeforeSuspend, ___T>,
2852 ) -> impl ::core::future::Future<Output = ()>;
2853
2854 #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2855 fn after_resume(
2856 &mut self,
2857
2858 responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___T>,
2859 ) -> impl ::core::future::Future<Output = ()>;
2860
2861 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
2862 ::core::future::ready(())
2863 }
2864}
2865
2866impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for SuspendBlocker
2867where
2868 ___H: SuspendBlockerLocalServerHandler<___T>,
2869 ___T: ::fidl_next::Transport,
2870{
2871 async fn on_one_way(
2872 handler: &mut ___H,
2873 mut message: ::fidl_next::Message<___T>,
2874 ) -> ::core::result::Result<
2875 (),
2876 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2877 > {
2878 match *message.header().ordinal {
2879 ordinal => {
2880 handler.on_unknown_interaction(ordinal).await;
2881 if ::core::matches!(
2882 message.header().flexibility(),
2883 ::fidl_next::protocol::Flexibility::Strict
2884 ) {
2885 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2886 } else {
2887 Ok(())
2888 }
2889 }
2890 }
2891 }
2892
2893 async fn on_two_way(
2894 handler: &mut ___H,
2895 mut message: ::fidl_next::Message<___T>,
2896 responder: ::fidl_next::protocol::Responder<___T>,
2897 ) -> ::core::result::Result<
2898 (),
2899 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
2900 > {
2901 match *message.header().ordinal {
2902 7734531672310967680 => {
2903 let responder = ::fidl_next::Responder::from_untyped(responder);
2904
2905 handler.before_suspend(responder).await;
2906 Ok(())
2907 }
2908
2909 7652351326344392170 => {
2910 let responder = ::fidl_next::Responder::from_untyped(responder);
2911
2912 handler.after_resume(responder).await;
2913 Ok(())
2914 }
2915
2916 ordinal => {
2917 handler.on_unknown_interaction(ordinal).await;
2918 if ::core::matches!(
2919 message.header().flexibility(),
2920 ::fidl_next::protocol::Flexibility::Strict
2921 ) {
2922 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2923 } else {
2924 responder
2925 .respond_framework_error(
2926 ordinal,
2927 ::fidl_next::FrameworkError::UnknownMethod,
2928 )
2929 .expect("encoding a framework error should never fail")
2930 .await?;
2931 Ok(())
2932 }
2933 }
2934 }
2935 }
2936}
2937
2938pub trait SuspendBlockerClientHandler<
2942 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2943 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2944>
2945{
2946 fn on_unknown_interaction(
2947 &mut self,
2948 ordinal: u64,
2949 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
2950 ::core::future::ready(())
2951 }
2952}
2953
2954impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for SuspendBlocker
2955where
2956 ___H: SuspendBlockerClientHandler<___T> + ::core::marker::Send,
2957 ___T: ::fidl_next::Transport,
2958{
2959 async fn on_event(
2960 handler: &mut ___H,
2961 mut message: ::fidl_next::Message<___T>,
2962 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
2963 match *message.header().ordinal {
2964 ordinal => {
2965 handler.on_unknown_interaction(ordinal).await;
2966 if ::core::matches!(
2967 message.header().flexibility(),
2968 ::fidl_next::protocol::Flexibility::Strict
2969 ) {
2970 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
2971 } else {
2972 Ok(())
2973 }
2974 }
2975 }
2976 }
2977}
2978
2979pub trait SuspendBlockerServerHandler<
2983 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
2984 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
2985>
2986{
2987 #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2988 fn before_suspend(
2989 &mut self,
2990
2991 responder: ::fidl_next::Responder<suspend_blocker::BeforeSuspend, ___T>,
2992 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
2993
2994 #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
2995 fn after_resume(
2996 &mut self,
2997
2998 responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___T>,
2999 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
3000
3001 fn on_unknown_interaction(
3002 &mut self,
3003 ordinal: u64,
3004 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
3005 ::core::future::ready(())
3006 }
3007}
3008
3009impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for SuspendBlocker
3010where
3011 ___H: SuspendBlockerServerHandler<___T> + ::core::marker::Send,
3012 ___T: ::fidl_next::Transport,
3013{
3014 async fn on_one_way(
3015 handler: &mut ___H,
3016 mut message: ::fidl_next::Message<___T>,
3017 ) -> ::core::result::Result<
3018 (),
3019 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3020 > {
3021 match *message.header().ordinal {
3022 ordinal => {
3023 handler.on_unknown_interaction(ordinal).await;
3024 if ::core::matches!(
3025 message.header().flexibility(),
3026 ::fidl_next::protocol::Flexibility::Strict
3027 ) {
3028 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
3029 } else {
3030 Ok(())
3031 }
3032 }
3033 }
3034 }
3035
3036 async fn on_two_way(
3037 handler: &mut ___H,
3038 mut message: ::fidl_next::Message<___T>,
3039 responder: ::fidl_next::protocol::Responder<___T>,
3040 ) -> ::core::result::Result<
3041 (),
3042 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
3043 > {
3044 match *message.header().ordinal {
3045 7734531672310967680 => {
3046 let responder = ::fidl_next::Responder::from_untyped(responder);
3047
3048 handler.before_suspend(responder).await;
3049 Ok(())
3050 }
3051
3052 7652351326344392170 => {
3053 let responder = ::fidl_next::Responder::from_untyped(responder);
3054
3055 handler.after_resume(responder).await;
3056 Ok(())
3057 }
3058
3059 ordinal => {
3060 handler.on_unknown_interaction(ordinal).await;
3061 if ::core::matches!(
3062 message.header().flexibility(),
3063 ::fidl_next::protocol::Flexibility::Strict
3064 ) {
3065 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
3066 } else {
3067 responder
3068 .respond_framework_error(
3069 ordinal,
3070 ::fidl_next::FrameworkError::UnknownMethod,
3071 )
3072 .expect("encoding a framework error should never fail")
3073 .await?;
3074 Ok(())
3075 }
3076 }
3077 }
3078 }
3079}
3080
3081impl<___T> SuspendBlockerClientHandler<___T> for ::fidl_next::IgnoreEvents
3082where
3083 ___T: ::fidl_next::Transport,
3084{
3085 async fn on_unknown_interaction(&mut self, _: u64) {}
3086}
3087
3088impl<___H, ___T> SuspendBlockerLocalClientHandler<___T> for ::fidl_next::Local<___H>
3089where
3090 ___H: SuspendBlockerClientHandler<___T>,
3091 ___T: ::fidl_next::Transport,
3092{
3093 async fn on_unknown_interaction(&mut self, ordinal: u64) {
3094 ___H::on_unknown_interaction(&mut self.0, ordinal).await
3095 }
3096}
3097
3098impl<___H, ___T> SuspendBlockerLocalServerHandler<___T> for ::fidl_next::Local<___H>
3099where
3100 ___H: SuspendBlockerServerHandler<___T>,
3101 ___T: ::fidl_next::Transport,
3102{
3103 async fn before_suspend(
3104 &mut self,
3105
3106 responder: ::fidl_next::Responder<suspend_blocker::BeforeSuspend, ___T>,
3107 ) {
3108 ___H::before_suspend(&mut self.0, responder).await
3109 }
3110
3111 async fn after_resume(
3112 &mut self,
3113
3114 responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___T>,
3115 ) {
3116 ___H::after_resume(&mut self.0, responder).await
3117 }
3118
3119 async fn on_unknown_interaction(&mut self, ordinal: u64) {
3120 ___H::on_unknown_interaction(&mut self.0, ordinal).await
3121 }
3122}