pw_bluetooth_att_emb/
att.rs

1#![allow(dead_code, unused_imports, unused_variables, non_camel_case_types, unused_parens)]
2
3use emboss_runtime::prelude::*;
4pub use emboss_runtime::{BitFlag, Error, Flag, InfallibleRead, Int, MutStorage, Storage, TryRead, TryWrite, UInt, View, VirtualField};
5
6
7
8#[derive(Copy, Clone, Debug, Eq, PartialEq)]
9#[repr(u64)]
10pub enum AttOpcode {
11    ATT_ERROR_RSP = 1,
12    ATT_EXCHANGE_MTU_REQ = 2,
13    ATT_EXCHANGE_MTU_RSP = 3,
14    ATT_FIND_INFORMATION_REQ = 4,
15    ATT_FIND_INFORMATION_RSP = 5,
16    ATT_FIND_BY_TYPE_VALUE_REQ = 6,
17    ATT_FIND_BY_TYPE_VALUE_RSP = 7,
18    ATT_READ_BY_TYPE_REQ = 8,
19    ATT_READ_BY_TYPE_RSP = 9,
20    ATT_READ_REQ = 10,
21    ATT_READ_RSP = 11,
22    ATT_READ_BLOB_REQ = 12,
23    ATT_READ_BLOB_RSP = 13,
24    ATT_READ_MULTIPLE_REQ = 14,
25    ATT_READ_MULTIPLE_RSP = 15,
26    ATT_READ_BY_GROUP_TYPE_REQ = 16,
27    ATT_READ_BY_GROUP_TYPE_RSP = 17,
28    ATT_WRITE_REQ = 18,
29    ATT_WRITE_RSP = 19,
30    ATT_WRITE_CMD = 82,
31    ATT_PREPARE_WRITE_REQ = 22,
32    ATT_PREPARE_WRITE_RSP = 23,
33    ATT_EXECUTE_WRITE_REQ = 24,
34    ATT_EXECUTE_WRITE_RSP = 25,
35    ATT_READ_MULTIPLE_VARIABLE_REQ = 32,
36    ATT_READ_MULTIPLE_VARIABLE_RSP = 33,
37    ATT_MULTIPLE_HANDLE_VALUE_NTF = 35,
38    ATT_HANDLE_VALUE_NTF = 27,
39    ATT_HANDLE_VALUE_IND = 29,
40    ATT_HANDLE_VALUE_CFM = 30,
41    ATT_SIGNED_WRITE_CMD = 210,
42
43}
44
45impl core::convert::From<AttOpcode> for u8 { fn from(val: AttOpcode) -> Self { val as u8 } }
46impl core::convert::From<AttOpcode> for u16 { fn from(val: AttOpcode) -> Self { val as u16 } }
47impl core::convert::From<AttOpcode> for u32 { fn from(val: AttOpcode) -> Self { val as u32 } }
48impl core::convert::From<AttOpcode> for u64 { fn from(val: AttOpcode) -> Self { val as u64 } }
49impl core::convert::From<AttOpcode> for i8 { fn from(val: AttOpcode) -> Self { val as i8 } }
50impl core::convert::From<AttOpcode> for i16 { fn from(val: AttOpcode) -> Self { val as i16 } }
51impl core::convert::From<AttOpcode> for i32 { fn from(val: AttOpcode) -> Self { val as i32 } }
52impl core::convert::From<AttOpcode> for i64 { fn from(val: AttOpcode) -> Self { val as i64 } }
53
54impl emboss_runtime::SafeCmp<AttOpcode> for AttOpcode {
55    fn safe_eq(&self, other: Self) -> bool { *self == other }
56    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
57}
58
59impl emboss_runtime::SafeCmp<u64> for AttOpcode {
60    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
61    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
62}
63
64impl emboss_runtime::SafeCmp<i64> for AttOpcode {
65    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
66    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
67}
68
69impl emboss_runtime::SafeCmp<i32> for AttOpcode {
70    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
71    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
72}
73
74impl emboss_runtime::SafeCmp<u32> for AttOpcode {
75    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
76    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
77}
78
79impl emboss_runtime::SafeCmp<AttOpcode> for u64 {
80    fn safe_eq(&self, other: AttOpcode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
81    fn safe_less(&self, other: AttOpcode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
82}
83
84impl emboss_runtime::SafeCmp<AttOpcode> for i64 {
85    fn safe_eq(&self, other: AttOpcode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
86    fn safe_less(&self, other: AttOpcode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
87}
88
89impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for AttOpcode {
90    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
91        let v_raw: u64 = val.into();
92        match v_raw {
93            1 => Ok(AttOpcode::ATT_ERROR_RSP),
94            2 => Ok(AttOpcode::ATT_EXCHANGE_MTU_REQ),
95            3 => Ok(AttOpcode::ATT_EXCHANGE_MTU_RSP),
96            4 => Ok(AttOpcode::ATT_FIND_INFORMATION_REQ),
97            5 => Ok(AttOpcode::ATT_FIND_INFORMATION_RSP),
98            6 => Ok(AttOpcode::ATT_FIND_BY_TYPE_VALUE_REQ),
99            7 => Ok(AttOpcode::ATT_FIND_BY_TYPE_VALUE_RSP),
100            8 => Ok(AttOpcode::ATT_READ_BY_TYPE_REQ),
101            9 => Ok(AttOpcode::ATT_READ_BY_TYPE_RSP),
102            10 => Ok(AttOpcode::ATT_READ_REQ),
103            11 => Ok(AttOpcode::ATT_READ_RSP),
104            12 => Ok(AttOpcode::ATT_READ_BLOB_REQ),
105            13 => Ok(AttOpcode::ATT_READ_BLOB_RSP),
106            14 => Ok(AttOpcode::ATT_READ_MULTIPLE_REQ),
107            15 => Ok(AttOpcode::ATT_READ_MULTIPLE_RSP),
108            16 => Ok(AttOpcode::ATT_READ_BY_GROUP_TYPE_REQ),
109            17 => Ok(AttOpcode::ATT_READ_BY_GROUP_TYPE_RSP),
110            18 => Ok(AttOpcode::ATT_WRITE_REQ),
111            19 => Ok(AttOpcode::ATT_WRITE_RSP),
112            82 => Ok(AttOpcode::ATT_WRITE_CMD),
113            22 => Ok(AttOpcode::ATT_PREPARE_WRITE_REQ),
114            23 => Ok(AttOpcode::ATT_PREPARE_WRITE_RSP),
115            24 => Ok(AttOpcode::ATT_EXECUTE_WRITE_REQ),
116            25 => Ok(AttOpcode::ATT_EXECUTE_WRITE_RSP),
117            32 => Ok(AttOpcode::ATT_READ_MULTIPLE_VARIABLE_REQ),
118            33 => Ok(AttOpcode::ATT_READ_MULTIPLE_VARIABLE_RSP),
119            35 => Ok(AttOpcode::ATT_MULTIPLE_HANDLE_VALUE_NTF),
120            27 => Ok(AttOpcode::ATT_HANDLE_VALUE_NTF),
121            29 => Ok(AttOpcode::ATT_HANDLE_VALUE_IND),
122            30 => Ok(AttOpcode::ATT_HANDLE_VALUE_CFM),
123            210 => Ok(AttOpcode::ATT_SIGNED_WRITE_CMD),
124
125            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
126        }
127    }
128}
129
130impl AttOpcode {
131
132}
133#[derive(Copy, Clone, Debug, Eq, PartialEq)]
134#[repr(u64)]
135pub enum ErrorCode {
136    INVALID_HANDLE = 1,
137    READ_NOT_PERMITTED = 2,
138    WRITE_NOT_PERMITTED = 3,
139    INVALID_PDU = 4,
140    INSUFFICIENT_AUTHENTICATION = 5,
141    REQUEST_NOT_SUPPORTED = 6,
142    INVALID_OFFSET = 7,
143    INSUFFICIENT_AUTHORIZATION = 8,
144    PREPARE_QUEUE_FULL = 9,
145    ATTRIBUTE_NOT_FOUND = 10,
146    ATTRIBUTE_NOT_LONG = 11,
147    INSUFFICIENT_ENCRYPTION_KEY_SIZE = 12,
148    INVALID_ATTRIBUTE_VALUE_LENGTH = 13,
149    UNLIKELY_ERROR = 14,
150    INSUFFICIENT_ENCRYPTION = 15,
151    UNSUPPORTED_GROUP_TYPE = 16,
152    INSUFFICIENT_RESOURCES = 17,
153    VALUE_NOT_ALLOWED = 19,
154
155}
156
157impl core::convert::From<ErrorCode> for u8 { fn from(val: ErrorCode) -> Self { val as u8 } }
158impl core::convert::From<ErrorCode> for u16 { fn from(val: ErrorCode) -> Self { val as u16 } }
159impl core::convert::From<ErrorCode> for u32 { fn from(val: ErrorCode) -> Self { val as u32 } }
160impl core::convert::From<ErrorCode> for u64 { fn from(val: ErrorCode) -> Self { val as u64 } }
161impl core::convert::From<ErrorCode> for i8 { fn from(val: ErrorCode) -> Self { val as i8 } }
162impl core::convert::From<ErrorCode> for i16 { fn from(val: ErrorCode) -> Self { val as i16 } }
163impl core::convert::From<ErrorCode> for i32 { fn from(val: ErrorCode) -> Self { val as i32 } }
164impl core::convert::From<ErrorCode> for i64 { fn from(val: ErrorCode) -> Self { val as i64 } }
165
166impl emboss_runtime::SafeCmp<ErrorCode> for ErrorCode {
167    fn safe_eq(&self, other: Self) -> bool { *self == other }
168    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
169}
170
171impl emboss_runtime::SafeCmp<u64> for ErrorCode {
172    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
173    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
174}
175
176impl emboss_runtime::SafeCmp<i64> for ErrorCode {
177    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
178    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
179}
180
181impl emboss_runtime::SafeCmp<i32> for ErrorCode {
182    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
183    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
184}
185
186impl emboss_runtime::SafeCmp<u32> for ErrorCode {
187    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
188    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
189}
190
191impl emboss_runtime::SafeCmp<ErrorCode> for u64 {
192    fn safe_eq(&self, other: ErrorCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
193    fn safe_less(&self, other: ErrorCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
194}
195
196impl emboss_runtime::SafeCmp<ErrorCode> for i64 {
197    fn safe_eq(&self, other: ErrorCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
198    fn safe_less(&self, other: ErrorCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
199}
200
201impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for ErrorCode {
202    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
203        let v_raw: u64 = val.into();
204        match v_raw {
205            1 => Ok(ErrorCode::INVALID_HANDLE),
206            2 => Ok(ErrorCode::READ_NOT_PERMITTED),
207            3 => Ok(ErrorCode::WRITE_NOT_PERMITTED),
208            4 => Ok(ErrorCode::INVALID_PDU),
209            5 => Ok(ErrorCode::INSUFFICIENT_AUTHENTICATION),
210            6 => Ok(ErrorCode::REQUEST_NOT_SUPPORTED),
211            7 => Ok(ErrorCode::INVALID_OFFSET),
212            8 => Ok(ErrorCode::INSUFFICIENT_AUTHORIZATION),
213            9 => Ok(ErrorCode::PREPARE_QUEUE_FULL),
214            10 => Ok(ErrorCode::ATTRIBUTE_NOT_FOUND),
215            11 => Ok(ErrorCode::ATTRIBUTE_NOT_LONG),
216            12 => Ok(ErrorCode::INSUFFICIENT_ENCRYPTION_KEY_SIZE),
217            13 => Ok(ErrorCode::INVALID_ATTRIBUTE_VALUE_LENGTH),
218            14 => Ok(ErrorCode::UNLIKELY_ERROR),
219            15 => Ok(ErrorCode::INSUFFICIENT_ENCRYPTION),
220            16 => Ok(ErrorCode::UNSUPPORTED_GROUP_TYPE),
221            17 => Ok(ErrorCode::INSUFFICIENT_RESOURCES),
222            19 => Ok(ErrorCode::VALUE_NOT_ALLOWED),
223
224            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
225        }
226    }
227}
228
229impl ErrorCode {
230
231}
232pub struct AttHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
233    storage: S,
234    _marker: core::marker::PhantomData<ST>,
235}
236
237impl<S: emboss_runtime::Storage> AttHeader<S, emboss_runtime::UncheckedState> {
238    pub fn new(storage: S) -> Self {
239        Self {
240            storage,
241            _marker: core::marker::PhantomData,
242        }
243    }
244}
245
246impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttHeader<S, ST> {
247    fn clone(&self) -> Self {
248        Self {
249            storage: self.storage.clone(),
250            _marker: core::marker::PhantomData,
251        }
252    }
253}
254
255impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttHeader<S, ST> {
256    /**
257     * Constructs a view in a specific typestate.
258     *
259     * # Safety
260     *
261     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
262     */
263    pub unsafe fn new_in_state(storage: S) -> Self {
264        Self {
265            storage,
266            _marker: core::marker::PhantomData,
267        }
268    }
269    pub fn into_storage(self) -> S {
270        self.storage
271    }
272    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
273        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
274            let offset = (0) as usize;
275            let len = (1) as usize;
276            core::result::Result::Ok((offset, len))
277        })().unwrap_or((usize::MAX, 0));
278        let storage = self.storage.slice(offset, len);
279        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
280    }
281
282}
283
284pub struct AttHeaderMut<S: emboss_runtime::MutStorage> {
285    storage: S,
286}
287
288impl<S: emboss_runtime::MutStorage> AttHeaderMut<S> {
289    pub fn new(storage: S) -> Self {
290        Self {
291            storage,
292        }
293    }
294    pub fn into_writer(self) -> AttHeaderWriter<S, emboss_runtime::UncheckedState> {
295        AttHeaderWriter::new(self.storage)
296    }
297    /** Borrows the mutable view as an immutable view in UncheckedState. */
298    pub fn as_view(&self) -> AttHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
299        unsafe { AttHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
300    }
301    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
302        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
303            let offset = (0) as usize;
304            let len = (1) as usize;
305            core::result::Result::Ok((offset, len))
306        })().unwrap_or((usize::MAX, 0));
307        let storage = self.storage.slice_mut(offset, len);
308        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
309    }
310
311}
312
313impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttHeaderMut<S> {
314    type Writer = AttHeaderWriter<S, emboss_runtime::UncheckedState>;
315    fn into_writer(self) -> Self::Writer {
316        AttHeaderWriter::new(self.storage)
317    }
318}
319
320pub struct AttHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
321    storage: S,
322    _marker: core::marker::PhantomData<ST>,
323}
324
325impl<S: emboss_runtime::MutStorage> AttHeaderWriter<S, emboss_runtime::UncheckedState> {
326    pub fn new(storage: S) -> Self {
327        Self {
328            storage,
329            _marker: core::marker::PhantomData,
330        }
331    }
332}
333
334impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttHeaderWriter<S, ST> {
335    /**
336     * Constructs a writer in a specific typestate.
337     *
338     * # Safety
339     *
340     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
341     */
342    pub unsafe fn new_in_state(storage: S) -> Self {
343        Self {
344            storage,
345            _marker: core::marker::PhantomData,
346        }
347    }
348    pub fn into_storage(self) -> S {
349        self.storage
350    }
351    /** Converts the writer into an immutable view in the same typestate. */
352    pub fn into_view(self) -> AttHeader<S, ST> {
353        unsafe { AttHeader::new_in_state(self.storage) }
354    }
355    /** Borrows the writer as an immutable view in the same typestate. */
356    pub fn as_view(&self) -> AttHeader<S::Sliced<'_>, ST> {
357        unsafe { AttHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
358    }
359    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttHeaderWriter<S, ST::OnValidMutation> {
360        let view = self.into_view();
361        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
362            let offset = (0) as usize;
363            let len = (1) as usize;
364            core::result::Result::Ok((offset, len))
365        })().expect("valid layout in complete state");
366        let mut storage = view.into_storage();
367        {
368            let slice = storage.slice_mut(offset, len);
369            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
370            field_view.try_write(val).expect("valid write in complete state");
371        }
372        unsafe { AttHeaderWriter::new_in_state(storage) }
373    }
374
375}
376
377impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttHeader<S, ST> {
378    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
379        let view = self;
380        core::result::Result::Ok((1) as usize)
381    }
382}
383
384impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttHeaderMut<S> {
385    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
386        let view = self.as_view();
387        <AttHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
388    }
389}
390
391impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttHeaderWriter<S, ST> {
392    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
393        let view = self.as_view();
394        <AttHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
395    }
396}
397
398impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttHeader<S, emboss_runtime::UncheckedState> {
399    type Completed = AttHeader<S, emboss_runtime::CompleteState>;
400    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
401        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
402        if self.storage.len() < required_size {
403            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
404        }
405        core::result::Result::Ok(unsafe { AttHeader::new_in_state(self.storage) })
406    }
407}
408
409impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttHeaderWriter<S, emboss_runtime::UncheckedState> {
410    type Completed = AttHeaderWriter<S, emboss_runtime::CompleteState>;
411    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
412        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
413        if self.storage.len() < required_size {
414            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
415        }
416        core::result::Result::Ok(unsafe { AttHeaderWriter::new_in_state(self.storage) })
417    }
418}
419
420impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHeader<S, emboss_runtime::UncheckedState> {
421    type Ok = AttHeader<S, emboss_runtime::OkState>;
422    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
423        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
424        core::result::Result::Ok(unsafe { AttHeader::new_in_state(completed.into_storage()) })
425    }
426}
427
428impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHeader<S, emboss_runtime::CompleteState> {
429    type Ok = AttHeader<S, emboss_runtime::OkState>;
430    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
431        core::result::Result::Ok(unsafe { AttHeader::new_in_state(self.into_storage()) })
432    }
433}
434
435impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHeader<S, emboss_runtime::OkState> {
436    type Ok = AttHeader<S, emboss_runtime::OkState>;
437    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
438        core::result::Result::Ok(self)
439    }
440}
441
442impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHeaderWriter<S, emboss_runtime::UncheckedState> {
443    type Ok = AttHeaderWriter<S, emboss_runtime::OkState>;
444    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
445        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
446        core::result::Result::Ok(unsafe { AttHeaderWriter::new_in_state(completed.into_storage()) })
447    }
448}
449
450impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHeaderWriter<S, emboss_runtime::CompleteState> {
451    type Ok = AttHeaderWriter<S, emboss_runtime::OkState>;
452    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
453        core::result::Result::Ok(unsafe { AttHeaderWriter::new_in_state(self.into_storage()) })
454    }
455}
456
457impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHeaderWriter<S, emboss_runtime::OkState> {
458    type Ok = AttHeaderWriter<S, emboss_runtime::OkState>;
459    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
460        core::result::Result::Ok(self)
461    }
462}
463
464pub mod att_header {
465    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttHeader<S, ST>;
466    pub type ViewMut<S> = super::AttHeaderMut<S>;
467    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttHeaderWriter<S, ST>;
468
469    pub const MIN_SIZE_IN_BYTES: usize = 1;
470    pub const MAX_SIZE_IN_BYTES: usize = 1;
471    pub const SIZE_IN_BYTES: usize = 1;
472}pub struct AttErrorRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
473    storage: S,
474    _marker: core::marker::PhantomData<ST>,
475}
476
477impl<S: emboss_runtime::Storage> AttErrorRsp<S, emboss_runtime::UncheckedState> {
478    pub fn new(storage: S) -> Self {
479        Self {
480            storage,
481            _marker: core::marker::PhantomData,
482        }
483    }
484}
485
486impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttErrorRsp<S, ST> {
487    fn clone(&self) -> Self {
488        Self {
489            storage: self.storage.clone(),
490            _marker: core::marker::PhantomData,
491        }
492    }
493}
494
495impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttErrorRsp<S, ST> {
496    /**
497     * Constructs a view in a specific typestate.
498     *
499     * # Safety
500     *
501     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
502     */
503    pub unsafe fn new_in_state(storage: S) -> Self {
504        Self {
505            storage,
506            _marker: core::marker::PhantomData,
507        }
508    }
509    pub fn into_storage(self) -> S {
510        self.storage
511    }
512    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
513        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
514            let offset = (0) as usize;
515            let len = (1) as usize;
516            core::result::Result::Ok((offset, len))
517        })().unwrap_or((usize::MAX, 0));
518        let storage = self.storage.slice(offset, len);
519        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
520    }
521    pub fn request_opcode_in_error(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
522        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
523            let offset = (1) as usize;
524            let len = (1) as usize;
525            core::result::Result::Ok((offset, len))
526        })().unwrap_or((usize::MAX, 0));
527        let storage = self.storage.slice(offset, len);
528        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
529    }
530    pub fn request_opcode_in_error_uint(&self) -> UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
531        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
532            let offset = (1) as usize;
533            let len = (1) as usize;
534            core::result::Result::Ok((offset, len))
535        })().unwrap_or((usize::MAX, 0));
536        let storage = self.storage.slice(offset, len);
537        UInt::<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
538    }
539    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
540        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
541            let offset = (2) as usize;
542            let len = (2) as usize;
543            core::result::Result::Ok((offset, len))
544        })().unwrap_or((usize::MAX, 0));
545        let storage = self.storage.slice(offset, len);
546        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
547    }
548    pub fn error_code(&self) -> emboss_runtime::EnumView<ErrorCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
549        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
550            let offset = (4) as usize;
551            let len = (1) as usize;
552            core::result::Result::Ok((offset, len))
553        })().unwrap_or((usize::MAX, 0));
554        let storage = self.storage.slice(offset, len);
555        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
556    }
557
558}
559
560pub struct AttErrorRspMut<S: emboss_runtime::MutStorage> {
561    storage: S,
562}
563
564impl<S: emboss_runtime::MutStorage> AttErrorRspMut<S> {
565    pub fn new(storage: S) -> Self {
566        Self {
567            storage,
568        }
569    }
570    pub fn into_writer(self) -> AttErrorRspWriter<S, emboss_runtime::UncheckedState> {
571        AttErrorRspWriter::new(self.storage)
572    }
573    /** Borrows the mutable view as an immutable view in UncheckedState. */
574    pub fn as_view(&self) -> AttErrorRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
575        unsafe { AttErrorRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
576    }
577    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
578        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
579            let offset = (0) as usize;
580            let len = (1) as usize;
581            core::result::Result::Ok((offset, len))
582        })().unwrap_or((usize::MAX, 0));
583        let storage = self.storage.slice_mut(offset, len);
584        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
585    }
586    pub fn request_opcode_in_error(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
587        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
588            let offset = (1) as usize;
589            let len = (1) as usize;
590            core::result::Result::Ok((offset, len))
591        })().unwrap_or((usize::MAX, 0));
592        let storage = self.storage.slice_mut(offset, len);
593        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
594    }
595    pub fn request_opcode_in_error_uint(&mut self) -> UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
596        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
597            let offset = (1) as usize;
598            let len = (1) as usize;
599            core::result::Result::Ok((offset, len))
600        })().unwrap_or((usize::MAX, 0));
601        let storage = self.storage.slice_mut(offset, len);
602        UInt::<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
603    }
604    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
605        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
606            let offset = (2) as usize;
607            let len = (2) as usize;
608            core::result::Result::Ok((offset, len))
609        })().unwrap_or((usize::MAX, 0));
610        let storage = self.storage.slice_mut(offset, len);
611        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
612    }
613    pub fn error_code(&mut self) -> emboss_runtime::EnumViewMut<ErrorCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
614        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
615            let offset = (4) as usize;
616            let len = (1) as usize;
617            core::result::Result::Ok((offset, len))
618        })().unwrap_or((usize::MAX, 0));
619        let storage = self.storage.slice_mut(offset, len);
620        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
621    }
622
623}
624
625impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttErrorRspMut<S> {
626    type Writer = AttErrorRspWriter<S, emboss_runtime::UncheckedState>;
627    fn into_writer(self) -> Self::Writer {
628        AttErrorRspWriter::new(self.storage)
629    }
630}
631
632pub struct AttErrorRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
633    storage: S,
634    _marker: core::marker::PhantomData<ST>,
635}
636
637impl<S: emboss_runtime::MutStorage> AttErrorRspWriter<S, emboss_runtime::UncheckedState> {
638    pub fn new(storage: S) -> Self {
639        Self {
640            storage,
641            _marker: core::marker::PhantomData,
642        }
643    }
644}
645
646impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttErrorRspWriter<S, ST> {
647    /**
648     * Constructs a writer in a specific typestate.
649     *
650     * # Safety
651     *
652     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
653     */
654    pub unsafe fn new_in_state(storage: S) -> Self {
655        Self {
656            storage,
657            _marker: core::marker::PhantomData,
658        }
659    }
660    pub fn into_storage(self) -> S {
661        self.storage
662    }
663    /** Converts the writer into an immutable view in the same typestate. */
664    pub fn into_view(self) -> AttErrorRsp<S, ST> {
665        unsafe { AttErrorRsp::new_in_state(self.storage) }
666    }
667    /** Borrows the writer as an immutable view in the same typestate. */
668    pub fn as_view(&self) -> AttErrorRsp<S::Sliced<'_>, ST> {
669        unsafe { AttErrorRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
670    }
671    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttErrorRspWriter<S, ST::OnValidMutation> {
672        let view = self.into_view();
673        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
674            let offset = (0) as usize;
675            let len = (1) as usize;
676            core::result::Result::Ok((offset, len))
677        })().expect("valid layout in complete state");
678        let mut storage = view.into_storage();
679        {
680            let slice = storage.slice_mut(offset, len);
681            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
682            field_view.try_write(val).expect("valid write in complete state");
683        }
684        unsafe { AttErrorRspWriter::new_in_state(storage) }
685    }
686    pub fn write_request_opcode_in_error(self, val: AttOpcode) -> AttErrorRspWriter<S, ST::OnValidMutation> {
687        let view = self.into_view();
688        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
689            let offset = (1) as usize;
690            let len = (1) as usize;
691            core::result::Result::Ok((offset, len))
692        })().expect("valid layout in complete state");
693        let mut storage = view.into_storage();
694        {
695            let slice = storage.slice_mut(offset, len);
696            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
697            field_view.try_write(val).expect("valid write in complete state");
698        }
699        unsafe { AttErrorRspWriter::new_in_state(storage) }
700    }
701    pub fn write_request_opcode_in_error_uint(self, val: <emboss_runtime::SizeSelector<8> as emboss_runtime::SmallestUInt>::T) -> AttErrorRspWriter<S, ST::OnValidMutation> {
702        let view = self.into_view();
703        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
704            let offset = (1) as usize;
705            let len = (1) as usize;
706            core::result::Result::Ok((offset, len))
707        })().expect("valid layout in complete state");
708        let mut storage = view.into_storage();
709        {
710            let slice = storage.slice_mut(offset, len);
711            let mut field_view = emboss_runtime::UInt::<8, emboss_runtime::LittleEndian, _>::new(slice);
712            field_view.try_write(val).expect("valid write in complete state");
713        }
714        unsafe { AttErrorRspWriter::new_in_state(storage) }
715    }
716    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttErrorRspWriter<S, ST::OnValidMutation> {
717        let view = self.into_view();
718        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
719            let offset = (2) as usize;
720            let len = (2) as usize;
721            core::result::Result::Ok((offset, len))
722        })().expect("valid layout in complete state");
723        let mut storage = view.into_storage();
724        {
725            let slice = storage.slice_mut(offset, len);
726            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
727            field_view.try_write(val).expect("valid write in complete state");
728        }
729        unsafe { AttErrorRspWriter::new_in_state(storage) }
730    }
731    pub fn write_error_code(self, val: ErrorCode) -> AttErrorRspWriter<S, ST::OnValidMutation> {
732        let view = self.into_view();
733        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
734            let offset = (4) as usize;
735            let len = (1) as usize;
736            core::result::Result::Ok((offset, len))
737        })().expect("valid layout in complete state");
738        let mut storage = view.into_storage();
739        {
740            let slice = storage.slice_mut(offset, len);
741            let mut field_view = emboss_runtime::EnumViewMut::<ErrorCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
742            field_view.try_write(val).expect("valid write in complete state");
743        }
744        unsafe { AttErrorRspWriter::new_in_state(storage) }
745    }
746
747}
748
749impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttErrorRsp<S, ST> {
750    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
751        let view = self;
752        core::result::Result::Ok((5) as usize)
753    }
754}
755
756impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttErrorRspMut<S> {
757    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
758        let view = self.as_view();
759        <AttErrorRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
760    }
761}
762
763impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttErrorRspWriter<S, ST> {
764    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
765        let view = self.as_view();
766        <AttErrorRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
767    }
768}
769
770impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttErrorRsp<S, emboss_runtime::UncheckedState> {
771    type Completed = AttErrorRsp<S, emboss_runtime::CompleteState>;
772    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
773        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
774        if self.storage.len() < required_size {
775            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
776        }
777        core::result::Result::Ok(unsafe { AttErrorRsp::new_in_state(self.storage) })
778    }
779}
780
781impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttErrorRspWriter<S, emboss_runtime::UncheckedState> {
782    type Completed = AttErrorRspWriter<S, emboss_runtime::CompleteState>;
783    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
784        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
785        if self.storage.len() < required_size {
786            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
787        }
788        core::result::Result::Ok(unsafe { AttErrorRspWriter::new_in_state(self.storage) })
789    }
790}
791
792impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttErrorRsp<S, emboss_runtime::UncheckedState> {
793    type Ok = AttErrorRsp<S, emboss_runtime::OkState>;
794    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
795        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
796        core::result::Result::Ok(unsafe { AttErrorRsp::new_in_state(completed.into_storage()) })
797    }
798}
799
800impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttErrorRsp<S, emboss_runtime::CompleteState> {
801    type Ok = AttErrorRsp<S, emboss_runtime::OkState>;
802    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
803        core::result::Result::Ok(unsafe { AttErrorRsp::new_in_state(self.into_storage()) })
804    }
805}
806
807impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttErrorRsp<S, emboss_runtime::OkState> {
808    type Ok = AttErrorRsp<S, emboss_runtime::OkState>;
809    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
810        core::result::Result::Ok(self)
811    }
812}
813
814impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttErrorRspWriter<S, emboss_runtime::UncheckedState> {
815    type Ok = AttErrorRspWriter<S, emboss_runtime::OkState>;
816    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
817        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
818        core::result::Result::Ok(unsafe { AttErrorRspWriter::new_in_state(completed.into_storage()) })
819    }
820}
821
822impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttErrorRspWriter<S, emboss_runtime::CompleteState> {
823    type Ok = AttErrorRspWriter<S, emboss_runtime::OkState>;
824    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
825        core::result::Result::Ok(unsafe { AttErrorRspWriter::new_in_state(self.into_storage()) })
826    }
827}
828
829impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttErrorRspWriter<S, emboss_runtime::OkState> {
830    type Ok = AttErrorRspWriter<S, emboss_runtime::OkState>;
831    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
832        core::result::Result::Ok(self)
833    }
834}
835
836pub mod att_error_rsp {
837    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttErrorRsp<S, ST>;
838    pub type ViewMut<S> = super::AttErrorRspMut<S>;
839    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttErrorRspWriter<S, ST>;
840
841    pub const MIN_SIZE_IN_BYTES: usize = 5;
842    pub const MAX_SIZE_IN_BYTES: usize = 5;
843    pub const SIZE_IN_BYTES: usize = 5;
844}pub struct AttExchangeMtuReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
845    storage: S,
846    _marker: core::marker::PhantomData<ST>,
847}
848
849impl<S: emboss_runtime::Storage> AttExchangeMtuReq<S, emboss_runtime::UncheckedState> {
850    pub fn new(storage: S) -> Self {
851        Self {
852            storage,
853            _marker: core::marker::PhantomData,
854        }
855    }
856}
857
858impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttExchangeMtuReq<S, ST> {
859    fn clone(&self) -> Self {
860        Self {
861            storage: self.storage.clone(),
862            _marker: core::marker::PhantomData,
863        }
864    }
865}
866
867impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttExchangeMtuReq<S, ST> {
868    /**
869     * Constructs a view in a specific typestate.
870     *
871     * # Safety
872     *
873     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
874     */
875    pub unsafe fn new_in_state(storage: S) -> Self {
876        Self {
877            storage,
878            _marker: core::marker::PhantomData,
879        }
880    }
881    pub fn into_storage(self) -> S {
882        self.storage
883    }
884    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
885        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
886            let offset = (0) as usize;
887            let len = (1) as usize;
888            core::result::Result::Ok((offset, len))
889        })().unwrap_or((usize::MAX, 0));
890        let storage = self.storage.slice(offset, len);
891        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
892    }
893    pub fn client_rx_mtu(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
894        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
895            let offset = (1) as usize;
896            let len = (2) as usize;
897            core::result::Result::Ok((offset, len))
898        })().unwrap_or((usize::MAX, 0));
899        let storage = self.storage.slice(offset, len);
900        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
901    }
902
903}
904
905pub struct AttExchangeMtuReqMut<S: emboss_runtime::MutStorage> {
906    storage: S,
907}
908
909impl<S: emboss_runtime::MutStorage> AttExchangeMtuReqMut<S> {
910    pub fn new(storage: S) -> Self {
911        Self {
912            storage,
913        }
914    }
915    pub fn into_writer(self) -> AttExchangeMtuReqWriter<S, emboss_runtime::UncheckedState> {
916        AttExchangeMtuReqWriter::new(self.storage)
917    }
918    /** Borrows the mutable view as an immutable view in UncheckedState. */
919    pub fn as_view(&self) -> AttExchangeMtuReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
920        unsafe { AttExchangeMtuReq::new_in_state(self.storage.slice(0, self.storage.len())) }
921    }
922    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
923        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
924            let offset = (0) as usize;
925            let len = (1) as usize;
926            core::result::Result::Ok((offset, len))
927        })().unwrap_or((usize::MAX, 0));
928        let storage = self.storage.slice_mut(offset, len);
929        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
930    }
931    pub fn client_rx_mtu(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
932        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
933            let offset = (1) as usize;
934            let len = (2) as usize;
935            core::result::Result::Ok((offset, len))
936        })().unwrap_or((usize::MAX, 0));
937        let storage = self.storage.slice_mut(offset, len);
938        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
939    }
940
941}
942
943impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttExchangeMtuReqMut<S> {
944    type Writer = AttExchangeMtuReqWriter<S, emboss_runtime::UncheckedState>;
945    fn into_writer(self) -> Self::Writer {
946        AttExchangeMtuReqWriter::new(self.storage)
947    }
948}
949
950pub struct AttExchangeMtuReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
951    storage: S,
952    _marker: core::marker::PhantomData<ST>,
953}
954
955impl<S: emboss_runtime::MutStorage> AttExchangeMtuReqWriter<S, emboss_runtime::UncheckedState> {
956    pub fn new(storage: S) -> Self {
957        Self {
958            storage,
959            _marker: core::marker::PhantomData,
960        }
961    }
962}
963
964impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttExchangeMtuReqWriter<S, ST> {
965    /**
966     * Constructs a writer in a specific typestate.
967     *
968     * # Safety
969     *
970     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
971     */
972    pub unsafe fn new_in_state(storage: S) -> Self {
973        Self {
974            storage,
975            _marker: core::marker::PhantomData,
976        }
977    }
978    pub fn into_storage(self) -> S {
979        self.storage
980    }
981    /** Converts the writer into an immutable view in the same typestate. */
982    pub fn into_view(self) -> AttExchangeMtuReq<S, ST> {
983        unsafe { AttExchangeMtuReq::new_in_state(self.storage) }
984    }
985    /** Borrows the writer as an immutable view in the same typestate. */
986    pub fn as_view(&self) -> AttExchangeMtuReq<S::Sliced<'_>, ST> {
987        unsafe { AttExchangeMtuReq::new_in_state(self.storage.slice(0, self.storage.len())) }
988    }
989    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttExchangeMtuReqWriter<S, ST::OnValidMutation> {
990        let view = self.into_view();
991        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
992            let offset = (0) as usize;
993            let len = (1) as usize;
994            core::result::Result::Ok((offset, len))
995        })().expect("valid layout in complete state");
996        let mut storage = view.into_storage();
997        {
998            let slice = storage.slice_mut(offset, len);
999            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
1000            field_view.try_write(val).expect("valid write in complete state");
1001        }
1002        unsafe { AttExchangeMtuReqWriter::new_in_state(storage) }
1003    }
1004    pub fn write_client_rx_mtu(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttExchangeMtuReqWriter<S, ST::OnValidMutation> {
1005        let view = self.into_view();
1006        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1007            let offset = (1) as usize;
1008            let len = (2) as usize;
1009            core::result::Result::Ok((offset, len))
1010        })().expect("valid layout in complete state");
1011        let mut storage = view.into_storage();
1012        {
1013            let slice = storage.slice_mut(offset, len);
1014            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
1015            field_view.try_write(val).expect("valid write in complete state");
1016        }
1017        unsafe { AttExchangeMtuReqWriter::new_in_state(storage) }
1018    }
1019
1020}
1021
1022impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttExchangeMtuReq<S, ST> {
1023    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1024        let view = self;
1025        core::result::Result::Ok((3) as usize)
1026    }
1027}
1028
1029impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttExchangeMtuReqMut<S> {
1030    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1031        let view = self.as_view();
1032        <AttExchangeMtuReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1033    }
1034}
1035
1036impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttExchangeMtuReqWriter<S, ST> {
1037    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1038        let view = self.as_view();
1039        <AttExchangeMtuReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1040    }
1041}
1042
1043impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttExchangeMtuReq<S, emboss_runtime::UncheckedState> {
1044    type Completed = AttExchangeMtuReq<S, emboss_runtime::CompleteState>;
1045    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1046        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1047        if self.storage.len() < required_size {
1048            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1049        }
1050        core::result::Result::Ok(unsafe { AttExchangeMtuReq::new_in_state(self.storage) })
1051    }
1052}
1053
1054impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttExchangeMtuReqWriter<S, emboss_runtime::UncheckedState> {
1055    type Completed = AttExchangeMtuReqWriter<S, emboss_runtime::CompleteState>;
1056    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1057        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1058        if self.storage.len() < required_size {
1059            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1060        }
1061        core::result::Result::Ok(unsafe { AttExchangeMtuReqWriter::new_in_state(self.storage) })
1062    }
1063}
1064
1065impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuReq<S, emboss_runtime::UncheckedState> {
1066    type Ok = AttExchangeMtuReq<S, emboss_runtime::OkState>;
1067    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1068        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1069        core::result::Result::Ok(unsafe { AttExchangeMtuReq::new_in_state(completed.into_storage()) })
1070    }
1071}
1072
1073impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuReq<S, emboss_runtime::CompleteState> {
1074    type Ok = AttExchangeMtuReq<S, emboss_runtime::OkState>;
1075    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1076        core::result::Result::Ok(unsafe { AttExchangeMtuReq::new_in_state(self.into_storage()) })
1077    }
1078}
1079
1080impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuReq<S, emboss_runtime::OkState> {
1081    type Ok = AttExchangeMtuReq<S, emboss_runtime::OkState>;
1082    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1083        core::result::Result::Ok(self)
1084    }
1085}
1086
1087impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuReqWriter<S, emboss_runtime::UncheckedState> {
1088    type Ok = AttExchangeMtuReqWriter<S, emboss_runtime::OkState>;
1089    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1090        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1091        core::result::Result::Ok(unsafe { AttExchangeMtuReqWriter::new_in_state(completed.into_storage()) })
1092    }
1093}
1094
1095impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuReqWriter<S, emboss_runtime::CompleteState> {
1096    type Ok = AttExchangeMtuReqWriter<S, emboss_runtime::OkState>;
1097    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1098        core::result::Result::Ok(unsafe { AttExchangeMtuReqWriter::new_in_state(self.into_storage()) })
1099    }
1100}
1101
1102impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuReqWriter<S, emboss_runtime::OkState> {
1103    type Ok = AttExchangeMtuReqWriter<S, emboss_runtime::OkState>;
1104    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1105        core::result::Result::Ok(self)
1106    }
1107}
1108
1109pub mod att_exchange_mtu_req {
1110    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttExchangeMtuReq<S, ST>;
1111    pub type ViewMut<S> = super::AttExchangeMtuReqMut<S>;
1112    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttExchangeMtuReqWriter<S, ST>;
1113
1114    pub const MIN_SIZE_IN_BYTES: usize = 3;
1115    pub const MAX_SIZE_IN_BYTES: usize = 3;
1116    pub const SIZE_IN_BYTES: usize = 3;
1117}pub struct AttExchangeMtuRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1118    storage: S,
1119    _marker: core::marker::PhantomData<ST>,
1120}
1121
1122impl<S: emboss_runtime::Storage> AttExchangeMtuRsp<S, emboss_runtime::UncheckedState> {
1123    pub fn new(storage: S) -> Self {
1124        Self {
1125            storage,
1126            _marker: core::marker::PhantomData,
1127        }
1128    }
1129}
1130
1131impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttExchangeMtuRsp<S, ST> {
1132    fn clone(&self) -> Self {
1133        Self {
1134            storage: self.storage.clone(),
1135            _marker: core::marker::PhantomData,
1136        }
1137    }
1138}
1139
1140impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttExchangeMtuRsp<S, ST> {
1141    /**
1142     * Constructs a view in a specific typestate.
1143     *
1144     * # Safety
1145     *
1146     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1147     */
1148    pub unsafe fn new_in_state(storage: S) -> Self {
1149        Self {
1150            storage,
1151            _marker: core::marker::PhantomData,
1152        }
1153    }
1154    pub fn into_storage(self) -> S {
1155        self.storage
1156    }
1157    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
1158        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1159            let offset = (0) as usize;
1160            let len = (1) as usize;
1161            core::result::Result::Ok((offset, len))
1162        })().unwrap_or((usize::MAX, 0));
1163        let storage = self.storage.slice(offset, len);
1164        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
1165    }
1166    pub fn server_rx_mtu(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
1167        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1168            let offset = (1) as usize;
1169            let len = (2) as usize;
1170            core::result::Result::Ok((offset, len))
1171        })().unwrap_or((usize::MAX, 0));
1172        let storage = self.storage.slice(offset, len);
1173        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
1174    }
1175
1176}
1177
1178pub struct AttExchangeMtuRspMut<S: emboss_runtime::MutStorage> {
1179    storage: S,
1180}
1181
1182impl<S: emboss_runtime::MutStorage> AttExchangeMtuRspMut<S> {
1183    pub fn new(storage: S) -> Self {
1184        Self {
1185            storage,
1186        }
1187    }
1188    pub fn into_writer(self) -> AttExchangeMtuRspWriter<S, emboss_runtime::UncheckedState> {
1189        AttExchangeMtuRspWriter::new(self.storage)
1190    }
1191    /** Borrows the mutable view as an immutable view in UncheckedState. */
1192    pub fn as_view(&self) -> AttExchangeMtuRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1193        unsafe { AttExchangeMtuRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
1194    }
1195    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1196        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1197            let offset = (0) as usize;
1198            let len = (1) as usize;
1199            core::result::Result::Ok((offset, len))
1200        })().unwrap_or((usize::MAX, 0));
1201        let storage = self.storage.slice_mut(offset, len);
1202        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
1203    }
1204    pub fn server_rx_mtu(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1205        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1206            let offset = (1) as usize;
1207            let len = (2) as usize;
1208            core::result::Result::Ok((offset, len))
1209        })().unwrap_or((usize::MAX, 0));
1210        let storage = self.storage.slice_mut(offset, len);
1211        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1212    }
1213
1214}
1215
1216impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttExchangeMtuRspMut<S> {
1217    type Writer = AttExchangeMtuRspWriter<S, emboss_runtime::UncheckedState>;
1218    fn into_writer(self) -> Self::Writer {
1219        AttExchangeMtuRspWriter::new(self.storage)
1220    }
1221}
1222
1223pub struct AttExchangeMtuRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1224    storage: S,
1225    _marker: core::marker::PhantomData<ST>,
1226}
1227
1228impl<S: emboss_runtime::MutStorage> AttExchangeMtuRspWriter<S, emboss_runtime::UncheckedState> {
1229    pub fn new(storage: S) -> Self {
1230        Self {
1231            storage,
1232            _marker: core::marker::PhantomData,
1233        }
1234    }
1235}
1236
1237impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttExchangeMtuRspWriter<S, ST> {
1238    /**
1239     * Constructs a writer in a specific typestate.
1240     *
1241     * # Safety
1242     *
1243     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1244     */
1245    pub unsafe fn new_in_state(storage: S) -> Self {
1246        Self {
1247            storage,
1248            _marker: core::marker::PhantomData,
1249        }
1250    }
1251    pub fn into_storage(self) -> S {
1252        self.storage
1253    }
1254    /** Converts the writer into an immutable view in the same typestate. */
1255    pub fn into_view(self) -> AttExchangeMtuRsp<S, ST> {
1256        unsafe { AttExchangeMtuRsp::new_in_state(self.storage) }
1257    }
1258    /** Borrows the writer as an immutable view in the same typestate. */
1259    pub fn as_view(&self) -> AttExchangeMtuRsp<S::Sliced<'_>, ST> {
1260        unsafe { AttExchangeMtuRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
1261    }
1262    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttExchangeMtuRspWriter<S, ST::OnValidMutation> {
1263        let view = self.into_view();
1264        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1265            let offset = (0) as usize;
1266            let len = (1) as usize;
1267            core::result::Result::Ok((offset, len))
1268        })().expect("valid layout in complete state");
1269        let mut storage = view.into_storage();
1270        {
1271            let slice = storage.slice_mut(offset, len);
1272            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
1273            field_view.try_write(val).expect("valid write in complete state");
1274        }
1275        unsafe { AttExchangeMtuRspWriter::new_in_state(storage) }
1276    }
1277    pub fn write_server_rx_mtu(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttExchangeMtuRspWriter<S, ST::OnValidMutation> {
1278        let view = self.into_view();
1279        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1280            let offset = (1) as usize;
1281            let len = (2) as usize;
1282            core::result::Result::Ok((offset, len))
1283        })().expect("valid layout in complete state");
1284        let mut storage = view.into_storage();
1285        {
1286            let slice = storage.slice_mut(offset, len);
1287            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
1288            field_view.try_write(val).expect("valid write in complete state");
1289        }
1290        unsafe { AttExchangeMtuRspWriter::new_in_state(storage) }
1291    }
1292
1293}
1294
1295impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttExchangeMtuRsp<S, ST> {
1296    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1297        let view = self;
1298        core::result::Result::Ok((3) as usize)
1299    }
1300}
1301
1302impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttExchangeMtuRspMut<S> {
1303    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1304        let view = self.as_view();
1305        <AttExchangeMtuRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1306    }
1307}
1308
1309impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttExchangeMtuRspWriter<S, ST> {
1310    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1311        let view = self.as_view();
1312        <AttExchangeMtuRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1313    }
1314}
1315
1316impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttExchangeMtuRsp<S, emboss_runtime::UncheckedState> {
1317    type Completed = AttExchangeMtuRsp<S, emboss_runtime::CompleteState>;
1318    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1319        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1320        if self.storage.len() < required_size {
1321            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1322        }
1323        core::result::Result::Ok(unsafe { AttExchangeMtuRsp::new_in_state(self.storage) })
1324    }
1325}
1326
1327impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttExchangeMtuRspWriter<S, emboss_runtime::UncheckedState> {
1328    type Completed = AttExchangeMtuRspWriter<S, emboss_runtime::CompleteState>;
1329    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1330        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1331        if self.storage.len() < required_size {
1332            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1333        }
1334        core::result::Result::Ok(unsafe { AttExchangeMtuRspWriter::new_in_state(self.storage) })
1335    }
1336}
1337
1338impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuRsp<S, emboss_runtime::UncheckedState> {
1339    type Ok = AttExchangeMtuRsp<S, emboss_runtime::OkState>;
1340    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1341        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1342        core::result::Result::Ok(unsafe { AttExchangeMtuRsp::new_in_state(completed.into_storage()) })
1343    }
1344}
1345
1346impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuRsp<S, emboss_runtime::CompleteState> {
1347    type Ok = AttExchangeMtuRsp<S, emboss_runtime::OkState>;
1348    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1349        core::result::Result::Ok(unsafe { AttExchangeMtuRsp::new_in_state(self.into_storage()) })
1350    }
1351}
1352
1353impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExchangeMtuRsp<S, emboss_runtime::OkState> {
1354    type Ok = AttExchangeMtuRsp<S, emboss_runtime::OkState>;
1355    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1356        core::result::Result::Ok(self)
1357    }
1358}
1359
1360impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuRspWriter<S, emboss_runtime::UncheckedState> {
1361    type Ok = AttExchangeMtuRspWriter<S, emboss_runtime::OkState>;
1362    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1363        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1364        core::result::Result::Ok(unsafe { AttExchangeMtuRspWriter::new_in_state(completed.into_storage()) })
1365    }
1366}
1367
1368impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuRspWriter<S, emboss_runtime::CompleteState> {
1369    type Ok = AttExchangeMtuRspWriter<S, emboss_runtime::OkState>;
1370    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1371        core::result::Result::Ok(unsafe { AttExchangeMtuRspWriter::new_in_state(self.into_storage()) })
1372    }
1373}
1374
1375impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExchangeMtuRspWriter<S, emboss_runtime::OkState> {
1376    type Ok = AttExchangeMtuRspWriter<S, emboss_runtime::OkState>;
1377    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1378        core::result::Result::Ok(self)
1379    }
1380}
1381
1382pub mod att_exchange_mtu_rsp {
1383    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttExchangeMtuRsp<S, ST>;
1384    pub type ViewMut<S> = super::AttExchangeMtuRspMut<S>;
1385    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttExchangeMtuRspWriter<S, ST>;
1386
1387    pub const MIN_SIZE_IN_BYTES: usize = 3;
1388    pub const MAX_SIZE_IN_BYTES: usize = 3;
1389    pub const SIZE_IN_BYTES: usize = 3;
1390}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
1391#[repr(u64)]
1392pub enum AttUuidFormat {
1393    BIT16 = 1,
1394    BIT128 = 2,
1395
1396}
1397
1398impl core::convert::From<AttUuidFormat> for u8 { fn from(val: AttUuidFormat) -> Self { val as u8 } }
1399impl core::convert::From<AttUuidFormat> for u16 { fn from(val: AttUuidFormat) -> Self { val as u16 } }
1400impl core::convert::From<AttUuidFormat> for u32 { fn from(val: AttUuidFormat) -> Self { val as u32 } }
1401impl core::convert::From<AttUuidFormat> for u64 { fn from(val: AttUuidFormat) -> Self { val as u64 } }
1402impl core::convert::From<AttUuidFormat> for i8 { fn from(val: AttUuidFormat) -> Self { val as i8 } }
1403impl core::convert::From<AttUuidFormat> for i16 { fn from(val: AttUuidFormat) -> Self { val as i16 } }
1404impl core::convert::From<AttUuidFormat> for i32 { fn from(val: AttUuidFormat) -> Self { val as i32 } }
1405impl core::convert::From<AttUuidFormat> for i64 { fn from(val: AttUuidFormat) -> Self { val as i64 } }
1406
1407impl emboss_runtime::SafeCmp<AttUuidFormat> for AttUuidFormat {
1408    fn safe_eq(&self, other: Self) -> bool { *self == other }
1409    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
1410}
1411
1412impl emboss_runtime::SafeCmp<u64> for AttUuidFormat {
1413    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1414    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1415}
1416
1417impl emboss_runtime::SafeCmp<i64> for AttUuidFormat {
1418    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1419    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1420}
1421
1422impl emboss_runtime::SafeCmp<i32> for AttUuidFormat {
1423    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
1424    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
1425}
1426
1427impl emboss_runtime::SafeCmp<u32> for AttUuidFormat {
1428    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
1429    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
1430}
1431
1432impl emboss_runtime::SafeCmp<AttUuidFormat> for u64 {
1433    fn safe_eq(&self, other: AttUuidFormat) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1434    fn safe_less(&self, other: AttUuidFormat) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1435}
1436
1437impl emboss_runtime::SafeCmp<AttUuidFormat> for i64 {
1438    fn safe_eq(&self, other: AttUuidFormat) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1439    fn safe_less(&self, other: AttUuidFormat) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1440}
1441
1442impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for AttUuidFormat {
1443    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
1444        let v_raw: u64 = val.into();
1445        match v_raw {
1446            1 => Ok(AttUuidFormat::BIT16),
1447            2 => Ok(AttUuidFormat::BIT128),
1448
1449            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
1450        }
1451    }
1452}
1453
1454impl AttUuidFormat {
1455
1456}
1457pub struct AttFindInformationReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1458    storage: S,
1459    _marker: core::marker::PhantomData<ST>,
1460}
1461
1462impl<S: emboss_runtime::Storage> AttFindInformationReq<S, emboss_runtime::UncheckedState> {
1463    pub fn new(storage: S) -> Self {
1464        Self {
1465            storage,
1466            _marker: core::marker::PhantomData,
1467        }
1468    }
1469}
1470
1471impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttFindInformationReq<S, ST> {
1472    fn clone(&self) -> Self {
1473        Self {
1474            storage: self.storage.clone(),
1475            _marker: core::marker::PhantomData,
1476        }
1477    }
1478}
1479
1480impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttFindInformationReq<S, ST> {
1481    /**
1482     * Constructs a view in a specific typestate.
1483     *
1484     * # Safety
1485     *
1486     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1487     */
1488    pub unsafe fn new_in_state(storage: S) -> Self {
1489        Self {
1490            storage,
1491            _marker: core::marker::PhantomData,
1492        }
1493    }
1494    pub fn into_storage(self) -> S {
1495        self.storage
1496    }
1497    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
1498        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1499            let offset = (0) as usize;
1500            let len = (1) as usize;
1501            core::result::Result::Ok((offset, len))
1502        })().unwrap_or((usize::MAX, 0));
1503        let storage = self.storage.slice(offset, len);
1504        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
1505    }
1506    pub fn starting_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
1507        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1508            let offset = (1) as usize;
1509            let len = (2) as usize;
1510            core::result::Result::Ok((offset, len))
1511        })().unwrap_or((usize::MAX, 0));
1512        let storage = self.storage.slice(offset, len);
1513        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
1514    }
1515    pub fn ending_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
1516        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1517            let offset = (3) as usize;
1518            let len = (2) as usize;
1519            core::result::Result::Ok((offset, len))
1520        })().unwrap_or((usize::MAX, 0));
1521        let storage = self.storage.slice(offset, len);
1522        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
1523    }
1524
1525}
1526
1527pub struct AttFindInformationReqMut<S: emboss_runtime::MutStorage> {
1528    storage: S,
1529}
1530
1531impl<S: emboss_runtime::MutStorage> AttFindInformationReqMut<S> {
1532    pub fn new(storage: S) -> Self {
1533        Self {
1534            storage,
1535        }
1536    }
1537    pub fn into_writer(self) -> AttFindInformationReqWriter<S, emboss_runtime::UncheckedState> {
1538        AttFindInformationReqWriter::new(self.storage)
1539    }
1540    /** Borrows the mutable view as an immutable view in UncheckedState. */
1541    pub fn as_view(&self) -> AttFindInformationReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1542        unsafe { AttFindInformationReq::new_in_state(self.storage.slice(0, self.storage.len())) }
1543    }
1544    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1545        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1546            let offset = (0) as usize;
1547            let len = (1) as usize;
1548            core::result::Result::Ok((offset, len))
1549        })().unwrap_or((usize::MAX, 0));
1550        let storage = self.storage.slice_mut(offset, len);
1551        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
1552    }
1553    pub fn starting_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1554        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1555            let offset = (1) as usize;
1556            let len = (2) as usize;
1557            core::result::Result::Ok((offset, len))
1558        })().unwrap_or((usize::MAX, 0));
1559        let storage = self.storage.slice_mut(offset, len);
1560        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1561    }
1562    pub fn ending_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1563        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1564            let offset = (3) as usize;
1565            let len = (2) as usize;
1566            core::result::Result::Ok((offset, len))
1567        })().unwrap_or((usize::MAX, 0));
1568        let storage = self.storage.slice_mut(offset, len);
1569        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1570    }
1571
1572}
1573
1574impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttFindInformationReqMut<S> {
1575    type Writer = AttFindInformationReqWriter<S, emboss_runtime::UncheckedState>;
1576    fn into_writer(self) -> Self::Writer {
1577        AttFindInformationReqWriter::new(self.storage)
1578    }
1579}
1580
1581pub struct AttFindInformationReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1582    storage: S,
1583    _marker: core::marker::PhantomData<ST>,
1584}
1585
1586impl<S: emboss_runtime::MutStorage> AttFindInformationReqWriter<S, emboss_runtime::UncheckedState> {
1587    pub fn new(storage: S) -> Self {
1588        Self {
1589            storage,
1590            _marker: core::marker::PhantomData,
1591        }
1592    }
1593}
1594
1595impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttFindInformationReqWriter<S, ST> {
1596    /**
1597     * Constructs a writer in a specific typestate.
1598     *
1599     * # Safety
1600     *
1601     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1602     */
1603    pub unsafe fn new_in_state(storage: S) -> Self {
1604        Self {
1605            storage,
1606            _marker: core::marker::PhantomData,
1607        }
1608    }
1609    pub fn into_storage(self) -> S {
1610        self.storage
1611    }
1612    /** Converts the writer into an immutable view in the same typestate. */
1613    pub fn into_view(self) -> AttFindInformationReq<S, ST> {
1614        unsafe { AttFindInformationReq::new_in_state(self.storage) }
1615    }
1616    /** Borrows the writer as an immutable view in the same typestate. */
1617    pub fn as_view(&self) -> AttFindInformationReq<S::Sliced<'_>, ST> {
1618        unsafe { AttFindInformationReq::new_in_state(self.storage.slice(0, self.storage.len())) }
1619    }
1620    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttFindInformationReqWriter<S, ST::OnValidMutation> {
1621        let view = self.into_view();
1622        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1623            let offset = (0) as usize;
1624            let len = (1) as usize;
1625            core::result::Result::Ok((offset, len))
1626        })().expect("valid layout in complete state");
1627        let mut storage = view.into_storage();
1628        {
1629            let slice = storage.slice_mut(offset, len);
1630            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
1631            field_view.try_write(val).expect("valid write in complete state");
1632        }
1633        unsafe { AttFindInformationReqWriter::new_in_state(storage) }
1634    }
1635    pub fn write_starting_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttFindInformationReqWriter<S, ST::OnValidMutation> {
1636        let view = self.into_view();
1637        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1638            let offset = (1) as usize;
1639            let len = (2) as usize;
1640            core::result::Result::Ok((offset, len))
1641        })().expect("valid layout in complete state");
1642        let mut storage = view.into_storage();
1643        {
1644            let slice = storage.slice_mut(offset, len);
1645            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
1646            field_view.try_write(val).expect("valid write in complete state");
1647        }
1648        unsafe { AttFindInformationReqWriter::new_in_state(storage) }
1649    }
1650    pub fn write_ending_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttFindInformationReqWriter<S, ST::OnValidMutation> {
1651        let view = self.into_view();
1652        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1653            let offset = (3) as usize;
1654            let len = (2) as usize;
1655            core::result::Result::Ok((offset, len))
1656        })().expect("valid layout in complete state");
1657        let mut storage = view.into_storage();
1658        {
1659            let slice = storage.slice_mut(offset, len);
1660            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
1661            field_view.try_write(val).expect("valid write in complete state");
1662        }
1663        unsafe { AttFindInformationReqWriter::new_in_state(storage) }
1664    }
1665
1666}
1667
1668impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttFindInformationReq<S, ST> {
1669    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1670        let view = self;
1671        core::result::Result::Ok((5) as usize)
1672    }
1673}
1674
1675impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttFindInformationReqMut<S> {
1676    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1677        let view = self.as_view();
1678        <AttFindInformationReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1679    }
1680}
1681
1682impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttFindInformationReqWriter<S, ST> {
1683    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1684        let view = self.as_view();
1685        <AttFindInformationReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1686    }
1687}
1688
1689impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttFindInformationReq<S, emboss_runtime::UncheckedState> {
1690    type Completed = AttFindInformationReq<S, emboss_runtime::CompleteState>;
1691    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1692        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1693        if self.storage.len() < required_size {
1694            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1695        }
1696        core::result::Result::Ok(unsafe { AttFindInformationReq::new_in_state(self.storage) })
1697    }
1698}
1699
1700impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttFindInformationReqWriter<S, emboss_runtime::UncheckedState> {
1701    type Completed = AttFindInformationReqWriter<S, emboss_runtime::CompleteState>;
1702    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1703        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1704        if self.storage.len() < required_size {
1705            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1706        }
1707        core::result::Result::Ok(unsafe { AttFindInformationReqWriter::new_in_state(self.storage) })
1708    }
1709}
1710
1711impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationReq<S, emboss_runtime::UncheckedState> {
1712    type Ok = AttFindInformationReq<S, emboss_runtime::OkState>;
1713    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1714        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1715        core::result::Result::Ok(unsafe { AttFindInformationReq::new_in_state(completed.into_storage()) })
1716    }
1717}
1718
1719impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationReq<S, emboss_runtime::CompleteState> {
1720    type Ok = AttFindInformationReq<S, emboss_runtime::OkState>;
1721    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1722        core::result::Result::Ok(unsafe { AttFindInformationReq::new_in_state(self.into_storage()) })
1723    }
1724}
1725
1726impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationReq<S, emboss_runtime::OkState> {
1727    type Ok = AttFindInformationReq<S, emboss_runtime::OkState>;
1728    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1729        core::result::Result::Ok(self)
1730    }
1731}
1732
1733impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationReqWriter<S, emboss_runtime::UncheckedState> {
1734    type Ok = AttFindInformationReqWriter<S, emboss_runtime::OkState>;
1735    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1736        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1737        core::result::Result::Ok(unsafe { AttFindInformationReqWriter::new_in_state(completed.into_storage()) })
1738    }
1739}
1740
1741impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationReqWriter<S, emboss_runtime::CompleteState> {
1742    type Ok = AttFindInformationReqWriter<S, emboss_runtime::OkState>;
1743    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1744        core::result::Result::Ok(unsafe { AttFindInformationReqWriter::new_in_state(self.into_storage()) })
1745    }
1746}
1747
1748impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationReqWriter<S, emboss_runtime::OkState> {
1749    type Ok = AttFindInformationReqWriter<S, emboss_runtime::OkState>;
1750    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1751        core::result::Result::Ok(self)
1752    }
1753}
1754
1755pub mod att_find_information_req {
1756    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttFindInformationReq<S, ST>;
1757    pub type ViewMut<S> = super::AttFindInformationReqMut<S>;
1758    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttFindInformationReqWriter<S, ST>;
1759
1760    pub const MIN_SIZE_IN_BYTES: usize = 5;
1761    pub const MAX_SIZE_IN_BYTES: usize = 5;
1762    pub const SIZE_IN_BYTES: usize = 5;
1763}pub struct AttFindInformationRspHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1764    storage: S,
1765    _marker: core::marker::PhantomData<ST>,
1766}
1767
1768impl<S: emboss_runtime::Storage> AttFindInformationRspHeader<S, emboss_runtime::UncheckedState> {
1769    pub fn new(storage: S) -> Self {
1770        Self {
1771            storage,
1772            _marker: core::marker::PhantomData,
1773        }
1774    }
1775}
1776
1777impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttFindInformationRspHeader<S, ST> {
1778    fn clone(&self) -> Self {
1779        Self {
1780            storage: self.storage.clone(),
1781            _marker: core::marker::PhantomData,
1782        }
1783    }
1784}
1785
1786impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttFindInformationRspHeader<S, ST> {
1787    /**
1788     * Constructs a view in a specific typestate.
1789     *
1790     * # Safety
1791     *
1792     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1793     */
1794    pub unsafe fn new_in_state(storage: S) -> Self {
1795        Self {
1796            storage,
1797            _marker: core::marker::PhantomData,
1798        }
1799    }
1800    pub fn into_storage(self) -> S {
1801        self.storage
1802    }
1803    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
1804        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1805            let offset = (0) as usize;
1806            let len = (1) as usize;
1807            core::result::Result::Ok((offset, len))
1808        })().unwrap_or((usize::MAX, 0));
1809        let storage = self.storage.slice(offset, len);
1810        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
1811    }
1812    pub fn format(&self) -> emboss_runtime::EnumView<AttUuidFormat, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
1813        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1814            let offset = (1) as usize;
1815            let len = (1) as usize;
1816            core::result::Result::Ok((offset, len))
1817        })().unwrap_or((usize::MAX, 0));
1818        let storage = self.storage.slice(offset, len);
1819        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
1820    }
1821
1822}
1823
1824pub struct AttFindInformationRspHeaderMut<S: emboss_runtime::MutStorage> {
1825    storage: S,
1826}
1827
1828impl<S: emboss_runtime::MutStorage> AttFindInformationRspHeaderMut<S> {
1829    pub fn new(storage: S) -> Self {
1830        Self {
1831            storage,
1832        }
1833    }
1834    pub fn into_writer(self) -> AttFindInformationRspHeaderWriter<S, emboss_runtime::UncheckedState> {
1835        AttFindInformationRspHeaderWriter::new(self.storage)
1836    }
1837    /** Borrows the mutable view as an immutable view in UncheckedState. */
1838    pub fn as_view(&self) -> AttFindInformationRspHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1839        unsafe { AttFindInformationRspHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
1840    }
1841    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1842        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1843            let offset = (0) as usize;
1844            let len = (1) as usize;
1845            core::result::Result::Ok((offset, len))
1846        })().unwrap_or((usize::MAX, 0));
1847        let storage = self.storage.slice_mut(offset, len);
1848        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
1849    }
1850    pub fn format(&mut self) -> emboss_runtime::EnumViewMut<AttUuidFormat, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1851        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1852            let offset = (1) as usize;
1853            let len = (1) as usize;
1854            core::result::Result::Ok((offset, len))
1855        })().unwrap_or((usize::MAX, 0));
1856        let storage = self.storage.slice_mut(offset, len);
1857        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
1858    }
1859
1860}
1861
1862impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttFindInformationRspHeaderMut<S> {
1863    type Writer = AttFindInformationRspHeaderWriter<S, emboss_runtime::UncheckedState>;
1864    fn into_writer(self) -> Self::Writer {
1865        AttFindInformationRspHeaderWriter::new(self.storage)
1866    }
1867}
1868
1869pub struct AttFindInformationRspHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1870    storage: S,
1871    _marker: core::marker::PhantomData<ST>,
1872}
1873
1874impl<S: emboss_runtime::MutStorage> AttFindInformationRspHeaderWriter<S, emboss_runtime::UncheckedState> {
1875    pub fn new(storage: S) -> Self {
1876        Self {
1877            storage,
1878            _marker: core::marker::PhantomData,
1879        }
1880    }
1881}
1882
1883impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttFindInformationRspHeaderWriter<S, ST> {
1884    /**
1885     * Constructs a writer in a specific typestate.
1886     *
1887     * # Safety
1888     *
1889     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1890     */
1891    pub unsafe fn new_in_state(storage: S) -> Self {
1892        Self {
1893            storage,
1894            _marker: core::marker::PhantomData,
1895        }
1896    }
1897    pub fn into_storage(self) -> S {
1898        self.storage
1899    }
1900    /** Converts the writer into an immutable view in the same typestate. */
1901    pub fn into_view(self) -> AttFindInformationRspHeader<S, ST> {
1902        unsafe { AttFindInformationRspHeader::new_in_state(self.storage) }
1903    }
1904    /** Borrows the writer as an immutable view in the same typestate. */
1905    pub fn as_view(&self) -> AttFindInformationRspHeader<S::Sliced<'_>, ST> {
1906        unsafe { AttFindInformationRspHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
1907    }
1908    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttFindInformationRspHeaderWriter<S, ST::OnValidMutation> {
1909        let view = self.into_view();
1910        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1911            let offset = (0) as usize;
1912            let len = (1) as usize;
1913            core::result::Result::Ok((offset, len))
1914        })().expect("valid layout in complete state");
1915        let mut storage = view.into_storage();
1916        {
1917            let slice = storage.slice_mut(offset, len);
1918            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
1919            field_view.try_write(val).expect("valid write in complete state");
1920        }
1921        unsafe { AttFindInformationRspHeaderWriter::new_in_state(storage) }
1922    }
1923    pub fn write_format(self, val: AttUuidFormat) -> AttFindInformationRspHeaderWriter<S, ST::OnValidMutation> {
1924        let view = self.into_view();
1925        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1926            let offset = (1) as usize;
1927            let len = (1) as usize;
1928            core::result::Result::Ok((offset, len))
1929        })().expect("valid layout in complete state");
1930        let mut storage = view.into_storage();
1931        {
1932            let slice = storage.slice_mut(offset, len);
1933            let mut field_view = emboss_runtime::EnumViewMut::<AttUuidFormat, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
1934            field_view.try_write(val).expect("valid write in complete state");
1935        }
1936        unsafe { AttFindInformationRspHeaderWriter::new_in_state(storage) }
1937    }
1938
1939}
1940
1941impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttFindInformationRspHeader<S, ST> {
1942    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1943        let view = self;
1944        core::result::Result::Ok((2) as usize)
1945    }
1946}
1947
1948impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttFindInformationRspHeaderMut<S> {
1949    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1950        let view = self.as_view();
1951        <AttFindInformationRspHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1952    }
1953}
1954
1955impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttFindInformationRspHeaderWriter<S, ST> {
1956    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1957        let view = self.as_view();
1958        <AttFindInformationRspHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1959    }
1960}
1961
1962impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttFindInformationRspHeader<S, emboss_runtime::UncheckedState> {
1963    type Completed = AttFindInformationRspHeader<S, emboss_runtime::CompleteState>;
1964    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1965        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1966        if self.storage.len() < required_size {
1967            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1968        }
1969        core::result::Result::Ok(unsafe { AttFindInformationRspHeader::new_in_state(self.storage) })
1970    }
1971}
1972
1973impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttFindInformationRspHeaderWriter<S, emboss_runtime::UncheckedState> {
1974    type Completed = AttFindInformationRspHeaderWriter<S, emboss_runtime::CompleteState>;
1975    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1976        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1977        if self.storage.len() < required_size {
1978            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1979        }
1980        core::result::Result::Ok(unsafe { AttFindInformationRspHeaderWriter::new_in_state(self.storage) })
1981    }
1982}
1983
1984impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationRspHeader<S, emboss_runtime::UncheckedState> {
1985    type Ok = AttFindInformationRspHeader<S, emboss_runtime::OkState>;
1986    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1987        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1988        core::result::Result::Ok(unsafe { AttFindInformationRspHeader::new_in_state(completed.into_storage()) })
1989    }
1990}
1991
1992impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationRspHeader<S, emboss_runtime::CompleteState> {
1993    type Ok = AttFindInformationRspHeader<S, emboss_runtime::OkState>;
1994    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1995        core::result::Result::Ok(unsafe { AttFindInformationRspHeader::new_in_state(self.into_storage()) })
1996    }
1997}
1998
1999impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindInformationRspHeader<S, emboss_runtime::OkState> {
2000    type Ok = AttFindInformationRspHeader<S, emboss_runtime::OkState>;
2001    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2002        core::result::Result::Ok(self)
2003    }
2004}
2005
2006impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationRspHeaderWriter<S, emboss_runtime::UncheckedState> {
2007    type Ok = AttFindInformationRspHeaderWriter<S, emboss_runtime::OkState>;
2008    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2009        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2010        core::result::Result::Ok(unsafe { AttFindInformationRspHeaderWriter::new_in_state(completed.into_storage()) })
2011    }
2012}
2013
2014impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationRspHeaderWriter<S, emboss_runtime::CompleteState> {
2015    type Ok = AttFindInformationRspHeaderWriter<S, emboss_runtime::OkState>;
2016    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2017        core::result::Result::Ok(unsafe { AttFindInformationRspHeaderWriter::new_in_state(self.into_storage()) })
2018    }
2019}
2020
2021impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindInformationRspHeaderWriter<S, emboss_runtime::OkState> {
2022    type Ok = AttFindInformationRspHeaderWriter<S, emboss_runtime::OkState>;
2023    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2024        core::result::Result::Ok(self)
2025    }
2026}
2027
2028pub mod att_find_information_rsp_header {
2029    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttFindInformationRspHeader<S, ST>;
2030    pub type ViewMut<S> = super::AttFindInformationRspHeaderMut<S>;
2031    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttFindInformationRspHeaderWriter<S, ST>;
2032
2033    pub const MIN_SIZE_IN_BYTES: usize = 2;
2034    pub const MAX_SIZE_IN_BYTES: usize = 2;
2035    pub const SIZE_IN_BYTES: usize = 2;
2036}pub struct AttInformationData16<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2037    storage: S,
2038    _marker: core::marker::PhantomData<ST>,
2039}
2040
2041impl<S: emboss_runtime::Storage> AttInformationData16<S, emboss_runtime::UncheckedState> {
2042    pub fn new(storage: S) -> Self {
2043        Self {
2044            storage,
2045            _marker: core::marker::PhantomData,
2046        }
2047    }
2048}
2049
2050impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttInformationData16<S, ST> {
2051    fn clone(&self) -> Self {
2052        Self {
2053            storage: self.storage.clone(),
2054            _marker: core::marker::PhantomData,
2055        }
2056    }
2057}
2058
2059impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttInformationData16<S, ST> {
2060    /**
2061     * Constructs a view in a specific typestate.
2062     *
2063     * # Safety
2064     *
2065     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2066     */
2067    pub unsafe fn new_in_state(storage: S) -> Self {
2068        Self {
2069            storage,
2070            _marker: core::marker::PhantomData,
2071        }
2072    }
2073    pub fn into_storage(self) -> S {
2074        self.storage
2075    }
2076    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2077        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2078            let offset = (0) as usize;
2079            let len = (2) as usize;
2080            core::result::Result::Ok((offset, len))
2081        })().unwrap_or((usize::MAX, 0));
2082        let storage = self.storage.slice(offset, len);
2083        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2084    }
2085    pub fn uuid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2086        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2087            let offset = (2) as usize;
2088            let len = (2) as usize;
2089            core::result::Result::Ok((offset, len))
2090        })().unwrap_or((usize::MAX, 0));
2091        let storage = self.storage.slice(offset, len);
2092        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2093    }
2094
2095}
2096
2097pub struct AttInformationData16Mut<S: emboss_runtime::MutStorage> {
2098    storage: S,
2099}
2100
2101impl<S: emboss_runtime::MutStorage> AttInformationData16Mut<S> {
2102    pub fn new(storage: S) -> Self {
2103        Self {
2104            storage,
2105        }
2106    }
2107    pub fn into_writer(self) -> AttInformationData16Writer<S, emboss_runtime::UncheckedState> {
2108        AttInformationData16Writer::new(self.storage)
2109    }
2110    /** Borrows the mutable view as an immutable view in UncheckedState. */
2111    pub fn as_view(&self) -> AttInformationData16<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2112        unsafe { AttInformationData16::new_in_state(self.storage.slice(0, self.storage.len())) }
2113    }
2114    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2115        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2116            let offset = (0) as usize;
2117            let len = (2) as usize;
2118            core::result::Result::Ok((offset, len))
2119        })().unwrap_or((usize::MAX, 0));
2120        let storage = self.storage.slice_mut(offset, len);
2121        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2122    }
2123    pub fn uuid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2124        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2125            let offset = (2) as usize;
2126            let len = (2) as usize;
2127            core::result::Result::Ok((offset, len))
2128        })().unwrap_or((usize::MAX, 0));
2129        let storage = self.storage.slice_mut(offset, len);
2130        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2131    }
2132
2133}
2134
2135impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttInformationData16Mut<S> {
2136    type Writer = AttInformationData16Writer<S, emboss_runtime::UncheckedState>;
2137    fn into_writer(self) -> Self::Writer {
2138        AttInformationData16Writer::new(self.storage)
2139    }
2140}
2141
2142pub struct AttInformationData16Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2143    storage: S,
2144    _marker: core::marker::PhantomData<ST>,
2145}
2146
2147impl<S: emboss_runtime::MutStorage> AttInformationData16Writer<S, emboss_runtime::UncheckedState> {
2148    pub fn new(storage: S) -> Self {
2149        Self {
2150            storage,
2151            _marker: core::marker::PhantomData,
2152        }
2153    }
2154}
2155
2156impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttInformationData16Writer<S, ST> {
2157    /**
2158     * Constructs a writer in a specific typestate.
2159     *
2160     * # Safety
2161     *
2162     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2163     */
2164    pub unsafe fn new_in_state(storage: S) -> Self {
2165        Self {
2166            storage,
2167            _marker: core::marker::PhantomData,
2168        }
2169    }
2170    pub fn into_storage(self) -> S {
2171        self.storage
2172    }
2173    /** Converts the writer into an immutable view in the same typestate. */
2174    pub fn into_view(self) -> AttInformationData16<S, ST> {
2175        unsafe { AttInformationData16::new_in_state(self.storage) }
2176    }
2177    /** Borrows the writer as an immutable view in the same typestate. */
2178    pub fn as_view(&self) -> AttInformationData16<S::Sliced<'_>, ST> {
2179        unsafe { AttInformationData16::new_in_state(self.storage.slice(0, self.storage.len())) }
2180    }
2181    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttInformationData16Writer<S, ST::OnValidMutation> {
2182        let view = self.into_view();
2183        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2184            let offset = (0) as usize;
2185            let len = (2) as usize;
2186            core::result::Result::Ok((offset, len))
2187        })().expect("valid layout in complete state");
2188        let mut storage = view.into_storage();
2189        {
2190            let slice = storage.slice_mut(offset, len);
2191            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2192            field_view.try_write(val).expect("valid write in complete state");
2193        }
2194        unsafe { AttInformationData16Writer::new_in_state(storage) }
2195    }
2196    pub fn write_uuid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttInformationData16Writer<S, ST::OnValidMutation> {
2197        let view = self.into_view();
2198        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2199            let offset = (2) as usize;
2200            let len = (2) as usize;
2201            core::result::Result::Ok((offset, len))
2202        })().expect("valid layout in complete state");
2203        let mut storage = view.into_storage();
2204        {
2205            let slice = storage.slice_mut(offset, len);
2206            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2207            field_view.try_write(val).expect("valid write in complete state");
2208        }
2209        unsafe { AttInformationData16Writer::new_in_state(storage) }
2210    }
2211
2212}
2213
2214impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttInformationData16<S, ST> {
2215    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2216        let view = self;
2217        core::result::Result::Ok((4) as usize)
2218    }
2219}
2220
2221impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttInformationData16Mut<S> {
2222    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2223        let view = self.as_view();
2224        <AttInformationData16<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2225    }
2226}
2227
2228impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttInformationData16Writer<S, ST> {
2229    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2230        let view = self.as_view();
2231        <AttInformationData16<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2232    }
2233}
2234
2235impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttInformationData16<S, emboss_runtime::UncheckedState> {
2236    type Completed = AttInformationData16<S, emboss_runtime::CompleteState>;
2237    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2238        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2239        if self.storage.len() < required_size {
2240            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2241        }
2242        core::result::Result::Ok(unsafe { AttInformationData16::new_in_state(self.storage) })
2243    }
2244}
2245
2246impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttInformationData16Writer<S, emboss_runtime::UncheckedState> {
2247    type Completed = AttInformationData16Writer<S, emboss_runtime::CompleteState>;
2248    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2249        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2250        if self.storage.len() < required_size {
2251            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2252        }
2253        core::result::Result::Ok(unsafe { AttInformationData16Writer::new_in_state(self.storage) })
2254    }
2255}
2256
2257impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData16<S, emboss_runtime::UncheckedState> {
2258    type Ok = AttInformationData16<S, emboss_runtime::OkState>;
2259    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2260        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2261        core::result::Result::Ok(unsafe { AttInformationData16::new_in_state(completed.into_storage()) })
2262    }
2263}
2264
2265impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData16<S, emboss_runtime::CompleteState> {
2266    type Ok = AttInformationData16<S, emboss_runtime::OkState>;
2267    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2268        core::result::Result::Ok(unsafe { AttInformationData16::new_in_state(self.into_storage()) })
2269    }
2270}
2271
2272impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData16<S, emboss_runtime::OkState> {
2273    type Ok = AttInformationData16<S, emboss_runtime::OkState>;
2274    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2275        core::result::Result::Ok(self)
2276    }
2277}
2278
2279impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData16Writer<S, emboss_runtime::UncheckedState> {
2280    type Ok = AttInformationData16Writer<S, emboss_runtime::OkState>;
2281    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2282        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2283        core::result::Result::Ok(unsafe { AttInformationData16Writer::new_in_state(completed.into_storage()) })
2284    }
2285}
2286
2287impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData16Writer<S, emboss_runtime::CompleteState> {
2288    type Ok = AttInformationData16Writer<S, emboss_runtime::OkState>;
2289    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2290        core::result::Result::Ok(unsafe { AttInformationData16Writer::new_in_state(self.into_storage()) })
2291    }
2292}
2293
2294impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData16Writer<S, emboss_runtime::OkState> {
2295    type Ok = AttInformationData16Writer<S, emboss_runtime::OkState>;
2296    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2297        core::result::Result::Ok(self)
2298    }
2299}
2300
2301pub mod att_information_data16 {
2302    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttInformationData16<S, ST>;
2303    pub type ViewMut<S> = super::AttInformationData16Mut<S>;
2304    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttInformationData16Writer<S, ST>;
2305
2306    pub const MIN_SIZE_IN_BYTES: usize = 4;
2307    pub const MAX_SIZE_IN_BYTES: usize = 4;
2308    pub const SIZE_IN_BYTES: usize = 4;
2309}pub struct AttInformationData128_Uuid_ArrayView<S: emboss_runtime::Storage> {
2310    storage: S,
2311    element_count: usize,
2312}
2313
2314impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for AttInformationData128_Uuid_ArrayView<S> {
2315    fn clone(&self) -> Self {
2316        Self {
2317            storage: self.storage.clone(),
2318            element_count: self.element_count,
2319        }
2320    }
2321}
2322
2323impl<S: emboss_runtime::Storage> AttInformationData128_Uuid_ArrayView<S> {
2324    pub const ELEMENT_SIZE_BYTES: usize = 1;
2325    pub fn new(storage: S, element_count: usize) -> Self {
2326        Self { storage, element_count }
2327    }
2328    pub fn element_count(&self) -> usize {
2329        self.element_count
2330    }
2331    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
2332, emboss_runtime::Error> {
2333        if index >= self.element_count {
2334            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2335        }
2336        let offset = index * Self::ELEMENT_SIZE_BYTES;
2337        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
2338        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
2339)
2340    }
2341}
2342
2343pub struct AttInformationData128_Uuid_ArrayViewMut<S: emboss_runtime::MutStorage> {
2344    storage: S,
2345    element_count: usize,
2346}
2347
2348impl<S: emboss_runtime::MutStorage> AttInformationData128_Uuid_ArrayViewMut<S> {
2349    pub const ELEMENT_SIZE_BYTES: usize = 1;
2350    pub fn new(storage: S, element_count: usize) -> Self {
2351        Self { storage, element_count }
2352    }
2353    pub fn element_count(&self) -> usize {
2354        self.element_count
2355    }
2356    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
2357, emboss_runtime::Error> {
2358        if index >= self.element_count {
2359            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2360        }
2361        let offset = index * Self::ELEMENT_SIZE_BYTES;
2362        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
2363        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
2364)
2365    }
2366}
2367pub struct AttInformationData128<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2368    storage: S,
2369    _marker: core::marker::PhantomData<ST>,
2370}
2371
2372impl<S: emboss_runtime::Storage> AttInformationData128<S, emboss_runtime::UncheckedState> {
2373    pub fn new(storage: S) -> Self {
2374        Self {
2375            storage,
2376            _marker: core::marker::PhantomData,
2377        }
2378    }
2379}
2380
2381impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttInformationData128<S, ST> {
2382    fn clone(&self) -> Self {
2383        Self {
2384            storage: self.storage.clone(),
2385            _marker: core::marker::PhantomData,
2386        }
2387    }
2388}
2389
2390impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttInformationData128<S, ST> {
2391    /**
2392     * Constructs a view in a specific typestate.
2393     *
2394     * # Safety
2395     *
2396     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2397     */
2398    pub unsafe fn new_in_state(storage: S) -> Self {
2399        Self {
2400            storage,
2401            _marker: core::marker::PhantomData,
2402        }
2403    }
2404    pub fn into_storage(self) -> S {
2405        self.storage
2406    }
2407    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2408        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2409            let offset = (0) as usize;
2410            let len = (2) as usize;
2411            core::result::Result::Ok((offset, len))
2412        })().unwrap_or((usize::MAX, 0));
2413        let storage = self.storage.slice(offset, len);
2414        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2415    }
2416    pub fn uuid(&self) -> core::result::Result<AttInformationData128_Uuid_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
2417        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
2418            let offset = (2) as usize;
2419            let len = (16) as usize;
2420            let element_count = (len / (1)) as usize;
2421            core::result::Result::Ok((offset, len, element_count))
2422        })();
2423        match offset_res {
2424            core::result::Result::Ok((offset, len, element_count)) => {
2425                if len > 0 {
2426                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
2427                    self.storage.try_read_byte(end - 1)?;
2428                }
2429                let storage = self.storage.slice(offset, len);
2430                core::result::Result::Ok(AttInformationData128_Uuid_ArrayView::new(storage, element_count))
2431            },
2432            core::result::Result::Err(e) => core::result::Result::Err(e),
2433        }
2434    }
2435
2436}
2437
2438pub struct AttInformationData128Mut<S: emboss_runtime::MutStorage> {
2439    storage: S,
2440}
2441
2442impl<S: emboss_runtime::MutStorage> AttInformationData128Mut<S> {
2443    pub fn new(storage: S) -> Self {
2444        Self {
2445            storage,
2446        }
2447    }
2448    pub fn into_writer(self) -> AttInformationData128Writer<S, emboss_runtime::UncheckedState> {
2449        AttInformationData128Writer::new(self.storage)
2450    }
2451    /** Borrows the mutable view as an immutable view in UncheckedState. */
2452    pub fn as_view(&self) -> AttInformationData128<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2453        unsafe { AttInformationData128::new_in_state(self.storage.slice(0, self.storage.len())) }
2454    }
2455    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2456        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2457            let offset = (0) as usize;
2458            let len = (2) as usize;
2459            core::result::Result::Ok((offset, len))
2460        })().unwrap_or((usize::MAX, 0));
2461        let storage = self.storage.slice_mut(offset, len);
2462        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2463    }
2464    pub fn uuid_mut(&mut self) -> core::result::Result<AttInformationData128_Uuid_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
2465        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
2466            let offset = (2) as usize;
2467            let len = (16) as usize;
2468            let element_count = (len / (1)) as usize;
2469            core::result::Result::Ok((offset, len, element_count))
2470        })();
2471        match offset_res {
2472            core::result::Result::Ok((offset, len, element_count)) => {
2473                if len > 0 {
2474                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
2475                    self.storage.try_read_byte(end - 1)?;
2476                }
2477                let storage = self.storage.slice_mut(offset, len);
2478                core::result::Result::Ok(AttInformationData128_Uuid_ArrayViewMut::new(storage, element_count))
2479            },
2480            core::result::Result::Err(e) => core::result::Result::Err(e),
2481        }
2482    }
2483
2484}
2485
2486impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttInformationData128Mut<S> {
2487    type Writer = AttInformationData128Writer<S, emboss_runtime::UncheckedState>;
2488    fn into_writer(self) -> Self::Writer {
2489        AttInformationData128Writer::new(self.storage)
2490    }
2491}
2492
2493pub struct AttInformationData128Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2494    storage: S,
2495    _marker: core::marker::PhantomData<ST>,
2496}
2497
2498impl<S: emboss_runtime::MutStorage> AttInformationData128Writer<S, emboss_runtime::UncheckedState> {
2499    pub fn new(storage: S) -> Self {
2500        Self {
2501            storage,
2502            _marker: core::marker::PhantomData,
2503        }
2504    }
2505}
2506
2507impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttInformationData128Writer<S, ST> {
2508    /**
2509     * Constructs a writer in a specific typestate.
2510     *
2511     * # Safety
2512     *
2513     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2514     */
2515    pub unsafe fn new_in_state(storage: S) -> Self {
2516        Self {
2517            storage,
2518            _marker: core::marker::PhantomData,
2519        }
2520    }
2521    pub fn into_storage(self) -> S {
2522        self.storage
2523    }
2524    /** Converts the writer into an immutable view in the same typestate. */
2525    pub fn into_view(self) -> AttInformationData128<S, ST> {
2526        unsafe { AttInformationData128::new_in_state(self.storage) }
2527    }
2528    /** Borrows the writer as an immutable view in the same typestate. */
2529    pub fn as_view(&self) -> AttInformationData128<S::Sliced<'_>, ST> {
2530        unsafe { AttInformationData128::new_in_state(self.storage.slice(0, self.storage.len())) }
2531    }
2532    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttInformationData128Writer<S, ST::OnValidMutation> {
2533        let view = self.into_view();
2534        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2535            let offset = (0) as usize;
2536            let len = (2) as usize;
2537            core::result::Result::Ok((offset, len))
2538        })().expect("valid layout in complete state");
2539        let mut storage = view.into_storage();
2540        {
2541            let slice = storage.slice_mut(offset, len);
2542            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2543            field_view.try_write(val).expect("valid write in complete state");
2544        }
2545        unsafe { AttInformationData128Writer::new_in_state(storage) }
2546    }
2547
2548}
2549
2550impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttInformationData128<S, ST> {
2551    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2552        let view = self;
2553        core::result::Result::Ok((18) as usize)
2554    }
2555}
2556
2557impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttInformationData128Mut<S> {
2558    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2559        let view = self.as_view();
2560        <AttInformationData128<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2561    }
2562}
2563
2564impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttInformationData128Writer<S, ST> {
2565    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2566        let view = self.as_view();
2567        <AttInformationData128<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2568    }
2569}
2570
2571impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttInformationData128<S, emboss_runtime::UncheckedState> {
2572    type Completed = AttInformationData128<S, emboss_runtime::CompleteState>;
2573    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2574        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2575        if self.storage.len() < required_size {
2576            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2577        }
2578        core::result::Result::Ok(unsafe { AttInformationData128::new_in_state(self.storage) })
2579    }
2580}
2581
2582impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttInformationData128Writer<S, emboss_runtime::UncheckedState> {
2583    type Completed = AttInformationData128Writer<S, emboss_runtime::CompleteState>;
2584    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2585        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2586        if self.storage.len() < required_size {
2587            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2588        }
2589        core::result::Result::Ok(unsafe { AttInformationData128Writer::new_in_state(self.storage) })
2590    }
2591}
2592
2593impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData128<S, emboss_runtime::UncheckedState> {
2594    type Ok = AttInformationData128<S, emboss_runtime::OkState>;
2595    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2596        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2597        core::result::Result::Ok(unsafe { AttInformationData128::new_in_state(completed.into_storage()) })
2598    }
2599}
2600
2601impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData128<S, emboss_runtime::CompleteState> {
2602    type Ok = AttInformationData128<S, emboss_runtime::OkState>;
2603    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2604        core::result::Result::Ok(unsafe { AttInformationData128::new_in_state(self.into_storage()) })
2605    }
2606}
2607
2608impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttInformationData128<S, emboss_runtime::OkState> {
2609    type Ok = AttInformationData128<S, emboss_runtime::OkState>;
2610    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2611        core::result::Result::Ok(self)
2612    }
2613}
2614
2615impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData128Writer<S, emboss_runtime::UncheckedState> {
2616    type Ok = AttInformationData128Writer<S, emboss_runtime::OkState>;
2617    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2618        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2619        core::result::Result::Ok(unsafe { AttInformationData128Writer::new_in_state(completed.into_storage()) })
2620    }
2621}
2622
2623impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData128Writer<S, emboss_runtime::CompleteState> {
2624    type Ok = AttInformationData128Writer<S, emboss_runtime::OkState>;
2625    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2626        core::result::Result::Ok(unsafe { AttInformationData128Writer::new_in_state(self.into_storage()) })
2627    }
2628}
2629
2630impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttInformationData128Writer<S, emboss_runtime::OkState> {
2631    type Ok = AttInformationData128Writer<S, emboss_runtime::OkState>;
2632    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2633        core::result::Result::Ok(self)
2634    }
2635}
2636
2637pub mod att_information_data128 {
2638    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttInformationData128<S, ST>;
2639    pub type ViewMut<S> = super::AttInformationData128Mut<S>;
2640    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttInformationData128Writer<S, ST>;
2641
2642    pub const MIN_SIZE_IN_BYTES: usize = 18;
2643    pub const MAX_SIZE_IN_BYTES: usize = 18;
2644    pub const SIZE_IN_BYTES: usize = 18;
2645}pub struct AttFindByTypeValueReqHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2646    storage: S,
2647    _marker: core::marker::PhantomData<ST>,
2648}
2649
2650impl<S: emboss_runtime::Storage> AttFindByTypeValueReqHeader<S, emboss_runtime::UncheckedState> {
2651    pub fn new(storage: S) -> Self {
2652        Self {
2653            storage,
2654            _marker: core::marker::PhantomData,
2655        }
2656    }
2657}
2658
2659impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttFindByTypeValueReqHeader<S, ST> {
2660    fn clone(&self) -> Self {
2661        Self {
2662            storage: self.storage.clone(),
2663            _marker: core::marker::PhantomData,
2664        }
2665    }
2666}
2667
2668impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttFindByTypeValueReqHeader<S, ST> {
2669    /**
2670     * Constructs a view in a specific typestate.
2671     *
2672     * # Safety
2673     *
2674     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2675     */
2676    pub unsafe fn new_in_state(storage: S) -> Self {
2677        Self {
2678            storage,
2679            _marker: core::marker::PhantomData,
2680        }
2681    }
2682    pub fn into_storage(self) -> S {
2683        self.storage
2684    }
2685    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
2686        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2687            let offset = (0) as usize;
2688            let len = (1) as usize;
2689            core::result::Result::Ok((offset, len))
2690        })().unwrap_or((usize::MAX, 0));
2691        let storage = self.storage.slice(offset, len);
2692        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
2693    }
2694    pub fn starting_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2695        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2696            let offset = (1) as usize;
2697            let len = (2) as usize;
2698            core::result::Result::Ok((offset, len))
2699        })().unwrap_or((usize::MAX, 0));
2700        let storage = self.storage.slice(offset, len);
2701        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2702    }
2703    pub fn ending_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2704        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2705            let offset = (3) as usize;
2706            let len = (2) as usize;
2707            core::result::Result::Ok((offset, len))
2708        })().unwrap_or((usize::MAX, 0));
2709        let storage = self.storage.slice(offset, len);
2710        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2711    }
2712    pub fn attribute_type(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
2713        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2714            let offset = (5) as usize;
2715            let len = (2) as usize;
2716            core::result::Result::Ok((offset, len))
2717        })().unwrap_or((usize::MAX, 0));
2718        let storage = self.storage.slice(offset, len);
2719        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
2720    }
2721
2722}
2723
2724pub struct AttFindByTypeValueReqHeaderMut<S: emboss_runtime::MutStorage> {
2725    storage: S,
2726}
2727
2728impl<S: emboss_runtime::MutStorage> AttFindByTypeValueReqHeaderMut<S> {
2729    pub fn new(storage: S) -> Self {
2730        Self {
2731            storage,
2732        }
2733    }
2734    pub fn into_writer(self) -> AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::UncheckedState> {
2735        AttFindByTypeValueReqHeaderWriter::new(self.storage)
2736    }
2737    /** Borrows the mutable view as an immutable view in UncheckedState. */
2738    pub fn as_view(&self) -> AttFindByTypeValueReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2739        unsafe { AttFindByTypeValueReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
2740    }
2741    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
2742        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2743            let offset = (0) as usize;
2744            let len = (1) as usize;
2745            core::result::Result::Ok((offset, len))
2746        })().unwrap_or((usize::MAX, 0));
2747        let storage = self.storage.slice_mut(offset, len);
2748        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
2749    }
2750    pub fn starting_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2751        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2752            let offset = (1) as usize;
2753            let len = (2) as usize;
2754            core::result::Result::Ok((offset, len))
2755        })().unwrap_or((usize::MAX, 0));
2756        let storage = self.storage.slice_mut(offset, len);
2757        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2758    }
2759    pub fn ending_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2760        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2761            let offset = (3) as usize;
2762            let len = (2) as usize;
2763            core::result::Result::Ok((offset, len))
2764        })().unwrap_or((usize::MAX, 0));
2765        let storage = self.storage.slice_mut(offset, len);
2766        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2767    }
2768    pub fn attribute_type(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2769        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2770            let offset = (5) as usize;
2771            let len = (2) as usize;
2772            core::result::Result::Ok((offset, len))
2773        })().unwrap_or((usize::MAX, 0));
2774        let storage = self.storage.slice_mut(offset, len);
2775        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2776    }
2777
2778}
2779
2780impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttFindByTypeValueReqHeaderMut<S> {
2781    type Writer = AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::UncheckedState>;
2782    fn into_writer(self) -> Self::Writer {
2783        AttFindByTypeValueReqHeaderWriter::new(self.storage)
2784    }
2785}
2786
2787pub struct AttFindByTypeValueReqHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2788    storage: S,
2789    _marker: core::marker::PhantomData<ST>,
2790}
2791
2792impl<S: emboss_runtime::MutStorage> AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::UncheckedState> {
2793    pub fn new(storage: S) -> Self {
2794        Self {
2795            storage,
2796            _marker: core::marker::PhantomData,
2797        }
2798    }
2799}
2800
2801impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttFindByTypeValueReqHeaderWriter<S, ST> {
2802    /**
2803     * Constructs a writer in a specific typestate.
2804     *
2805     * # Safety
2806     *
2807     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2808     */
2809    pub unsafe fn new_in_state(storage: S) -> Self {
2810        Self {
2811            storage,
2812            _marker: core::marker::PhantomData,
2813        }
2814    }
2815    pub fn into_storage(self) -> S {
2816        self.storage
2817    }
2818    /** Converts the writer into an immutable view in the same typestate. */
2819    pub fn into_view(self) -> AttFindByTypeValueReqHeader<S, ST> {
2820        unsafe { AttFindByTypeValueReqHeader::new_in_state(self.storage) }
2821    }
2822    /** Borrows the writer as an immutable view in the same typestate. */
2823    pub fn as_view(&self) -> AttFindByTypeValueReqHeader<S::Sliced<'_>, ST> {
2824        unsafe { AttFindByTypeValueReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
2825    }
2826    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttFindByTypeValueReqHeaderWriter<S, ST::OnValidMutation> {
2827        let view = self.into_view();
2828        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2829            let offset = (0) as usize;
2830            let len = (1) as usize;
2831            core::result::Result::Ok((offset, len))
2832        })().expect("valid layout in complete state");
2833        let mut storage = view.into_storage();
2834        {
2835            let slice = storage.slice_mut(offset, len);
2836            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
2837            field_view.try_write(val).expect("valid write in complete state");
2838        }
2839        unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(storage) }
2840    }
2841    pub fn write_starting_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttFindByTypeValueReqHeaderWriter<S, ST::OnValidMutation> {
2842        let view = self.into_view();
2843        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2844            let offset = (1) as usize;
2845            let len = (2) as usize;
2846            core::result::Result::Ok((offset, len))
2847        })().expect("valid layout in complete state");
2848        let mut storage = view.into_storage();
2849        {
2850            let slice = storage.slice_mut(offset, len);
2851            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2852            field_view.try_write(val).expect("valid write in complete state");
2853        }
2854        unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(storage) }
2855    }
2856    pub fn write_ending_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttFindByTypeValueReqHeaderWriter<S, ST::OnValidMutation> {
2857        let view = self.into_view();
2858        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2859            let offset = (3) as usize;
2860            let len = (2) as usize;
2861            core::result::Result::Ok((offset, len))
2862        })().expect("valid layout in complete state");
2863        let mut storage = view.into_storage();
2864        {
2865            let slice = storage.slice_mut(offset, len);
2866            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2867            field_view.try_write(val).expect("valid write in complete state");
2868        }
2869        unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(storage) }
2870    }
2871    pub fn write_attribute_type(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttFindByTypeValueReqHeaderWriter<S, ST::OnValidMutation> {
2872        let view = self.into_view();
2873        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2874            let offset = (5) as usize;
2875            let len = (2) as usize;
2876            core::result::Result::Ok((offset, len))
2877        })().expect("valid layout in complete state");
2878        let mut storage = view.into_storage();
2879        {
2880            let slice = storage.slice_mut(offset, len);
2881            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
2882            field_view.try_write(val).expect("valid write in complete state");
2883        }
2884        unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(storage) }
2885    }
2886
2887}
2888
2889impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttFindByTypeValueReqHeader<S, ST> {
2890    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2891        let view = self;
2892        core::result::Result::Ok((7) as usize)
2893    }
2894}
2895
2896impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttFindByTypeValueReqHeaderMut<S> {
2897    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2898        let view = self.as_view();
2899        <AttFindByTypeValueReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2900    }
2901}
2902
2903impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttFindByTypeValueReqHeaderWriter<S, ST> {
2904    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2905        let view = self.as_view();
2906        <AttFindByTypeValueReqHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2907    }
2908}
2909
2910impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttFindByTypeValueReqHeader<S, emboss_runtime::UncheckedState> {
2911    type Completed = AttFindByTypeValueReqHeader<S, emboss_runtime::CompleteState>;
2912    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2913        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2914        if self.storage.len() < required_size {
2915            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2916        }
2917        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeader::new_in_state(self.storage) })
2918    }
2919}
2920
2921impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::UncheckedState> {
2922    type Completed = AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::CompleteState>;
2923    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2924        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2925        if self.storage.len() < required_size {
2926            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2927        }
2928        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(self.storage) })
2929    }
2930}
2931
2932impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeader<S, emboss_runtime::UncheckedState> {
2933    type Ok = AttFindByTypeValueReqHeader<S, emboss_runtime::OkState>;
2934    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2935        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2936        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeader::new_in_state(completed.into_storage()) })
2937    }
2938}
2939
2940impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeader<S, emboss_runtime::CompleteState> {
2941    type Ok = AttFindByTypeValueReqHeader<S, emboss_runtime::OkState>;
2942    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2943        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeader::new_in_state(self.into_storage()) })
2944    }
2945}
2946
2947impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeader<S, emboss_runtime::OkState> {
2948    type Ok = AttFindByTypeValueReqHeader<S, emboss_runtime::OkState>;
2949    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2950        core::result::Result::Ok(self)
2951    }
2952}
2953
2954impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::UncheckedState> {
2955    type Ok = AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::OkState>;
2956    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2957        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2958        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(completed.into_storage()) })
2959    }
2960}
2961
2962impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::CompleteState> {
2963    type Ok = AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::OkState>;
2964    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2965        core::result::Result::Ok(unsafe { AttFindByTypeValueReqHeaderWriter::new_in_state(self.into_storage()) })
2966    }
2967}
2968
2969impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::OkState> {
2970    type Ok = AttFindByTypeValueReqHeaderWriter<S, emboss_runtime::OkState>;
2971    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2972        core::result::Result::Ok(self)
2973    }
2974}
2975
2976pub mod att_find_by_type_value_req_header {
2977    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttFindByTypeValueReqHeader<S, ST>;
2978    pub type ViewMut<S> = super::AttFindByTypeValueReqHeaderMut<S>;
2979    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttFindByTypeValueReqHeaderWriter<S, ST>;
2980
2981    pub const MIN_SIZE_IN_BYTES: usize = 7;
2982    pub const MAX_SIZE_IN_BYTES: usize = 7;
2983    pub const SIZE_IN_BYTES: usize = 7;
2984}pub struct AttHandlesInformation<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2985    storage: S,
2986    _marker: core::marker::PhantomData<ST>,
2987}
2988
2989impl<S: emboss_runtime::Storage> AttHandlesInformation<S, emboss_runtime::UncheckedState> {
2990    pub fn new(storage: S) -> Self {
2991        Self {
2992            storage,
2993            _marker: core::marker::PhantomData,
2994        }
2995    }
2996}
2997
2998impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttHandlesInformation<S, ST> {
2999    fn clone(&self) -> Self {
3000        Self {
3001            storage: self.storage.clone(),
3002            _marker: core::marker::PhantomData,
3003        }
3004    }
3005}
3006
3007impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttHandlesInformation<S, ST> {
3008    /**
3009     * Constructs a view in a specific typestate.
3010     *
3011     * # Safety
3012     *
3013     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3014     */
3015    pub unsafe fn new_in_state(storage: S) -> Self {
3016        Self {
3017            storage,
3018            _marker: core::marker::PhantomData,
3019        }
3020    }
3021    pub fn into_storage(self) -> S {
3022        self.storage
3023    }
3024    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3025        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3026            let offset = (0) as usize;
3027            let len = (2) as usize;
3028            core::result::Result::Ok((offset, len))
3029        })().unwrap_or((usize::MAX, 0));
3030        let storage = self.storage.slice(offset, len);
3031        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3032    }
3033    pub fn group_end_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3034        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3035            let offset = (2) as usize;
3036            let len = (2) as usize;
3037            core::result::Result::Ok((offset, len))
3038        })().unwrap_or((usize::MAX, 0));
3039        let storage = self.storage.slice(offset, len);
3040        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3041    }
3042
3043}
3044
3045pub struct AttHandlesInformationMut<S: emboss_runtime::MutStorage> {
3046    storage: S,
3047}
3048
3049impl<S: emboss_runtime::MutStorage> AttHandlesInformationMut<S> {
3050    pub fn new(storage: S) -> Self {
3051        Self {
3052            storage,
3053        }
3054    }
3055    pub fn into_writer(self) -> AttHandlesInformationWriter<S, emboss_runtime::UncheckedState> {
3056        AttHandlesInformationWriter::new(self.storage)
3057    }
3058    /** Borrows the mutable view as an immutable view in UncheckedState. */
3059    pub fn as_view(&self) -> AttHandlesInformation<S::Sliced<'_>, emboss_runtime::UncheckedState> {
3060        unsafe { AttHandlesInformation::new_in_state(self.storage.slice(0, self.storage.len())) }
3061    }
3062    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3063        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3064            let offset = (0) as usize;
3065            let len = (2) as usize;
3066            core::result::Result::Ok((offset, len))
3067        })().unwrap_or((usize::MAX, 0));
3068        let storage = self.storage.slice_mut(offset, len);
3069        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3070    }
3071    pub fn group_end_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3072        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3073            let offset = (2) as usize;
3074            let len = (2) as usize;
3075            core::result::Result::Ok((offset, len))
3076        })().unwrap_or((usize::MAX, 0));
3077        let storage = self.storage.slice_mut(offset, len);
3078        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3079    }
3080
3081}
3082
3083impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttHandlesInformationMut<S> {
3084    type Writer = AttHandlesInformationWriter<S, emboss_runtime::UncheckedState>;
3085    fn into_writer(self) -> Self::Writer {
3086        AttHandlesInformationWriter::new(self.storage)
3087    }
3088}
3089
3090pub struct AttHandlesInformationWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3091    storage: S,
3092    _marker: core::marker::PhantomData<ST>,
3093}
3094
3095impl<S: emboss_runtime::MutStorage> AttHandlesInformationWriter<S, emboss_runtime::UncheckedState> {
3096    pub fn new(storage: S) -> Self {
3097        Self {
3098            storage,
3099            _marker: core::marker::PhantomData,
3100        }
3101    }
3102}
3103
3104impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttHandlesInformationWriter<S, ST> {
3105    /**
3106     * Constructs a writer in a specific typestate.
3107     *
3108     * # Safety
3109     *
3110     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3111     */
3112    pub unsafe fn new_in_state(storage: S) -> Self {
3113        Self {
3114            storage,
3115            _marker: core::marker::PhantomData,
3116        }
3117    }
3118    pub fn into_storage(self) -> S {
3119        self.storage
3120    }
3121    /** Converts the writer into an immutable view in the same typestate. */
3122    pub fn into_view(self) -> AttHandlesInformation<S, ST> {
3123        unsafe { AttHandlesInformation::new_in_state(self.storage) }
3124    }
3125    /** Borrows the writer as an immutable view in the same typestate. */
3126    pub fn as_view(&self) -> AttHandlesInformation<S::Sliced<'_>, ST> {
3127        unsafe { AttHandlesInformation::new_in_state(self.storage.slice(0, self.storage.len())) }
3128    }
3129    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttHandlesInformationWriter<S, ST::OnValidMutation> {
3130        let view = self.into_view();
3131        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3132            let offset = (0) as usize;
3133            let len = (2) as usize;
3134            core::result::Result::Ok((offset, len))
3135        })().expect("valid layout in complete state");
3136        let mut storage = view.into_storage();
3137        {
3138            let slice = storage.slice_mut(offset, len);
3139            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3140            field_view.try_write(val).expect("valid write in complete state");
3141        }
3142        unsafe { AttHandlesInformationWriter::new_in_state(storage) }
3143    }
3144    pub fn write_group_end_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttHandlesInformationWriter<S, ST::OnValidMutation> {
3145        let view = self.into_view();
3146        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3147            let offset = (2) as usize;
3148            let len = (2) as usize;
3149            core::result::Result::Ok((offset, len))
3150        })().expect("valid layout in complete state");
3151        let mut storage = view.into_storage();
3152        {
3153            let slice = storage.slice_mut(offset, len);
3154            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3155            field_view.try_write(val).expect("valid write in complete state");
3156        }
3157        unsafe { AttHandlesInformationWriter::new_in_state(storage) }
3158    }
3159
3160}
3161
3162impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttHandlesInformation<S, ST> {
3163    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3164        let view = self;
3165        core::result::Result::Ok((4) as usize)
3166    }
3167}
3168
3169impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttHandlesInformationMut<S> {
3170    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3171        let view = self.as_view();
3172        <AttHandlesInformation<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
3173    }
3174}
3175
3176impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttHandlesInformationWriter<S, ST> {
3177    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3178        let view = self.as_view();
3179        <AttHandlesInformation<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
3180    }
3181}
3182
3183impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttHandlesInformation<S, emboss_runtime::UncheckedState> {
3184    type Completed = AttHandlesInformation<S, emboss_runtime::CompleteState>;
3185    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3186        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3187        if self.storage.len() < required_size {
3188            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3189        }
3190        core::result::Result::Ok(unsafe { AttHandlesInformation::new_in_state(self.storage) })
3191    }
3192}
3193
3194impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttHandlesInformationWriter<S, emboss_runtime::UncheckedState> {
3195    type Completed = AttHandlesInformationWriter<S, emboss_runtime::CompleteState>;
3196    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3197        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3198        if self.storage.len() < required_size {
3199            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3200        }
3201        core::result::Result::Ok(unsafe { AttHandlesInformationWriter::new_in_state(self.storage) })
3202    }
3203}
3204
3205impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandlesInformation<S, emboss_runtime::UncheckedState> {
3206    type Ok = AttHandlesInformation<S, emboss_runtime::OkState>;
3207    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3208        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3209        core::result::Result::Ok(unsafe { AttHandlesInformation::new_in_state(completed.into_storage()) })
3210    }
3211}
3212
3213impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandlesInformation<S, emboss_runtime::CompleteState> {
3214    type Ok = AttHandlesInformation<S, emboss_runtime::OkState>;
3215    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3216        core::result::Result::Ok(unsafe { AttHandlesInformation::new_in_state(self.into_storage()) })
3217    }
3218}
3219
3220impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandlesInformation<S, emboss_runtime::OkState> {
3221    type Ok = AttHandlesInformation<S, emboss_runtime::OkState>;
3222    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3223        core::result::Result::Ok(self)
3224    }
3225}
3226
3227impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandlesInformationWriter<S, emboss_runtime::UncheckedState> {
3228    type Ok = AttHandlesInformationWriter<S, emboss_runtime::OkState>;
3229    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3230        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3231        core::result::Result::Ok(unsafe { AttHandlesInformationWriter::new_in_state(completed.into_storage()) })
3232    }
3233}
3234
3235impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandlesInformationWriter<S, emboss_runtime::CompleteState> {
3236    type Ok = AttHandlesInformationWriter<S, emboss_runtime::OkState>;
3237    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3238        core::result::Result::Ok(unsafe { AttHandlesInformationWriter::new_in_state(self.into_storage()) })
3239    }
3240}
3241
3242impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandlesInformationWriter<S, emboss_runtime::OkState> {
3243    type Ok = AttHandlesInformationWriter<S, emboss_runtime::OkState>;
3244    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3245        core::result::Result::Ok(self)
3246    }
3247}
3248
3249pub mod att_handles_information {
3250    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttHandlesInformation<S, ST>;
3251    pub type ViewMut<S> = super::AttHandlesInformationMut<S>;
3252    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttHandlesInformationWriter<S, ST>;
3253
3254    pub const MIN_SIZE_IN_BYTES: usize = 4;
3255    pub const MAX_SIZE_IN_BYTES: usize = 4;
3256    pub const SIZE_IN_BYTES: usize = 4;
3257}pub struct AttReadByTypeReqHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3258    storage: S,
3259    _marker: core::marker::PhantomData<ST>,
3260}
3261
3262impl<S: emboss_runtime::Storage> AttReadByTypeReqHeader<S, emboss_runtime::UncheckedState> {
3263    pub fn new(storage: S) -> Self {
3264        Self {
3265            storage,
3266            _marker: core::marker::PhantomData,
3267        }
3268    }
3269}
3270
3271impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttReadByTypeReqHeader<S, ST> {
3272    fn clone(&self) -> Self {
3273        Self {
3274            storage: self.storage.clone(),
3275            _marker: core::marker::PhantomData,
3276        }
3277    }
3278}
3279
3280impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttReadByTypeReqHeader<S, ST> {
3281    /**
3282     * Constructs a view in a specific typestate.
3283     *
3284     * # Safety
3285     *
3286     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3287     */
3288    pub unsafe fn new_in_state(storage: S) -> Self {
3289        Self {
3290            storage,
3291            _marker: core::marker::PhantomData,
3292        }
3293    }
3294    pub fn into_storage(self) -> S {
3295        self.storage
3296    }
3297    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
3298        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3299            let offset = (0) as usize;
3300            let len = (1) as usize;
3301            core::result::Result::Ok((offset, len))
3302        })().unwrap_or((usize::MAX, 0));
3303        let storage = self.storage.slice(offset, len);
3304        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
3305    }
3306    pub fn starting_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3307        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3308            let offset = (1) as usize;
3309            let len = (2) as usize;
3310            core::result::Result::Ok((offset, len))
3311        })().unwrap_or((usize::MAX, 0));
3312        let storage = self.storage.slice(offset, len);
3313        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3314    }
3315    pub fn ending_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3316        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3317            let offset = (3) as usize;
3318            let len = (2) as usize;
3319            core::result::Result::Ok((offset, len))
3320        })().unwrap_or((usize::MAX, 0));
3321        let storage = self.storage.slice(offset, len);
3322        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3323    }
3324
3325}
3326
3327pub struct AttReadByTypeReqHeaderMut<S: emboss_runtime::MutStorage> {
3328    storage: S,
3329}
3330
3331impl<S: emboss_runtime::MutStorage> AttReadByTypeReqHeaderMut<S> {
3332    pub fn new(storage: S) -> Self {
3333        Self {
3334            storage,
3335        }
3336    }
3337    pub fn into_writer(self) -> AttReadByTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3338        AttReadByTypeReqHeaderWriter::new(self.storage)
3339    }
3340    /** Borrows the mutable view as an immutable view in UncheckedState. */
3341    pub fn as_view(&self) -> AttReadByTypeReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
3342        unsafe { AttReadByTypeReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
3343    }
3344    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
3345        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3346            let offset = (0) as usize;
3347            let len = (1) as usize;
3348            core::result::Result::Ok((offset, len))
3349        })().unwrap_or((usize::MAX, 0));
3350        let storage = self.storage.slice_mut(offset, len);
3351        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
3352    }
3353    pub fn starting_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3354        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3355            let offset = (1) as usize;
3356            let len = (2) as usize;
3357            core::result::Result::Ok((offset, len))
3358        })().unwrap_or((usize::MAX, 0));
3359        let storage = self.storage.slice_mut(offset, len);
3360        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3361    }
3362    pub fn ending_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3363        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3364            let offset = (3) as usize;
3365            let len = (2) as usize;
3366            core::result::Result::Ok((offset, len))
3367        })().unwrap_or((usize::MAX, 0));
3368        let storage = self.storage.slice_mut(offset, len);
3369        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3370    }
3371
3372}
3373
3374impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttReadByTypeReqHeaderMut<S> {
3375    type Writer = AttReadByTypeReqHeaderWriter<S, emboss_runtime::UncheckedState>;
3376    fn into_writer(self) -> Self::Writer {
3377        AttReadByTypeReqHeaderWriter::new(self.storage)
3378    }
3379}
3380
3381pub struct AttReadByTypeReqHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3382    storage: S,
3383    _marker: core::marker::PhantomData<ST>,
3384}
3385
3386impl<S: emboss_runtime::MutStorage> AttReadByTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3387    pub fn new(storage: S) -> Self {
3388        Self {
3389            storage,
3390            _marker: core::marker::PhantomData,
3391        }
3392    }
3393}
3394
3395impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttReadByTypeReqHeaderWriter<S, ST> {
3396    /**
3397     * Constructs a writer in a specific typestate.
3398     *
3399     * # Safety
3400     *
3401     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3402     */
3403    pub unsafe fn new_in_state(storage: S) -> Self {
3404        Self {
3405            storage,
3406            _marker: core::marker::PhantomData,
3407        }
3408    }
3409    pub fn into_storage(self) -> S {
3410        self.storage
3411    }
3412    /** Converts the writer into an immutable view in the same typestate. */
3413    pub fn into_view(self) -> AttReadByTypeReqHeader<S, ST> {
3414        unsafe { AttReadByTypeReqHeader::new_in_state(self.storage) }
3415    }
3416    /** Borrows the writer as an immutable view in the same typestate. */
3417    pub fn as_view(&self) -> AttReadByTypeReqHeader<S::Sliced<'_>, ST> {
3418        unsafe { AttReadByTypeReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
3419    }
3420    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttReadByTypeReqHeaderWriter<S, ST::OnValidMutation> {
3421        let view = self.into_view();
3422        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3423            let offset = (0) as usize;
3424            let len = (1) as usize;
3425            core::result::Result::Ok((offset, len))
3426        })().expect("valid layout in complete state");
3427        let mut storage = view.into_storage();
3428        {
3429            let slice = storage.slice_mut(offset, len);
3430            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
3431            field_view.try_write(val).expect("valid write in complete state");
3432        }
3433        unsafe { AttReadByTypeReqHeaderWriter::new_in_state(storage) }
3434    }
3435    pub fn write_starting_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByTypeReqHeaderWriter<S, ST::OnValidMutation> {
3436        let view = self.into_view();
3437        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3438            let offset = (1) as usize;
3439            let len = (2) as usize;
3440            core::result::Result::Ok((offset, len))
3441        })().expect("valid layout in complete state");
3442        let mut storage = view.into_storage();
3443        {
3444            let slice = storage.slice_mut(offset, len);
3445            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3446            field_view.try_write(val).expect("valid write in complete state");
3447        }
3448        unsafe { AttReadByTypeReqHeaderWriter::new_in_state(storage) }
3449    }
3450    pub fn write_ending_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByTypeReqHeaderWriter<S, ST::OnValidMutation> {
3451        let view = self.into_view();
3452        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3453            let offset = (3) as usize;
3454            let len = (2) as usize;
3455            core::result::Result::Ok((offset, len))
3456        })().expect("valid layout in complete state");
3457        let mut storage = view.into_storage();
3458        {
3459            let slice = storage.slice_mut(offset, len);
3460            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3461            field_view.try_write(val).expect("valid write in complete state");
3462        }
3463        unsafe { AttReadByTypeReqHeaderWriter::new_in_state(storage) }
3464    }
3465
3466}
3467
3468impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByTypeReqHeader<S, ST> {
3469    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3470        let view = self;
3471        core::result::Result::Ok((5) as usize)
3472    }
3473}
3474
3475impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttReadByTypeReqHeaderMut<S> {
3476    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3477        let view = self.as_view();
3478        <AttReadByTypeReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
3479    }
3480}
3481
3482impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByTypeReqHeaderWriter<S, ST> {
3483    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3484        let view = self.as_view();
3485        <AttReadByTypeReqHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
3486    }
3487}
3488
3489impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttReadByTypeReqHeader<S, emboss_runtime::UncheckedState> {
3490    type Completed = AttReadByTypeReqHeader<S, emboss_runtime::CompleteState>;
3491    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3492        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3493        if self.storage.len() < required_size {
3494            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3495        }
3496        core::result::Result::Ok(unsafe { AttReadByTypeReqHeader::new_in_state(self.storage) })
3497    }
3498}
3499
3500impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttReadByTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3501    type Completed = AttReadByTypeReqHeaderWriter<S, emboss_runtime::CompleteState>;
3502    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3503        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3504        if self.storage.len() < required_size {
3505            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3506        }
3507        core::result::Result::Ok(unsafe { AttReadByTypeReqHeaderWriter::new_in_state(self.storage) })
3508    }
3509}
3510
3511impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByTypeReqHeader<S, emboss_runtime::UncheckedState> {
3512    type Ok = AttReadByTypeReqHeader<S, emboss_runtime::OkState>;
3513    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3514        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3515        core::result::Result::Ok(unsafe { AttReadByTypeReqHeader::new_in_state(completed.into_storage()) })
3516    }
3517}
3518
3519impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByTypeReqHeader<S, emboss_runtime::CompleteState> {
3520    type Ok = AttReadByTypeReqHeader<S, emboss_runtime::OkState>;
3521    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3522        core::result::Result::Ok(unsafe { AttReadByTypeReqHeader::new_in_state(self.into_storage()) })
3523    }
3524}
3525
3526impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByTypeReqHeader<S, emboss_runtime::OkState> {
3527    type Ok = AttReadByTypeReqHeader<S, emboss_runtime::OkState>;
3528    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3529        core::result::Result::Ok(self)
3530    }
3531}
3532
3533impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3534    type Ok = AttReadByTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3535    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3536        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3537        core::result::Result::Ok(unsafe { AttReadByTypeReqHeaderWriter::new_in_state(completed.into_storage()) })
3538    }
3539}
3540
3541impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByTypeReqHeaderWriter<S, emboss_runtime::CompleteState> {
3542    type Ok = AttReadByTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3543    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3544        core::result::Result::Ok(unsafe { AttReadByTypeReqHeaderWriter::new_in_state(self.into_storage()) })
3545    }
3546}
3547
3548impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByTypeReqHeaderWriter<S, emboss_runtime::OkState> {
3549    type Ok = AttReadByTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3550    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3551        core::result::Result::Ok(self)
3552    }
3553}
3554
3555pub mod att_read_by_type_req_header {
3556    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttReadByTypeReqHeader<S, ST>;
3557    pub type ViewMut<S> = super::AttReadByTypeReqHeaderMut<S>;
3558    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttReadByTypeReqHeaderWriter<S, ST>;
3559
3560    pub const MIN_SIZE_IN_BYTES: usize = 5;
3561    pub const MAX_SIZE_IN_BYTES: usize = 5;
3562    pub const SIZE_IN_BYTES: usize = 5;
3563}pub struct AttReadByGroupTypeReqHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3564    storage: S,
3565    _marker: core::marker::PhantomData<ST>,
3566}
3567
3568impl<S: emboss_runtime::Storage> AttReadByGroupTypeReqHeader<S, emboss_runtime::UncheckedState> {
3569    pub fn new(storage: S) -> Self {
3570        Self {
3571            storage,
3572            _marker: core::marker::PhantomData,
3573        }
3574    }
3575}
3576
3577impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttReadByGroupTypeReqHeader<S, ST> {
3578    fn clone(&self) -> Self {
3579        Self {
3580            storage: self.storage.clone(),
3581            _marker: core::marker::PhantomData,
3582        }
3583    }
3584}
3585
3586impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttReadByGroupTypeReqHeader<S, ST> {
3587    /**
3588     * Constructs a view in a specific typestate.
3589     *
3590     * # Safety
3591     *
3592     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3593     */
3594    pub unsafe fn new_in_state(storage: S) -> Self {
3595        Self {
3596            storage,
3597            _marker: core::marker::PhantomData,
3598        }
3599    }
3600    pub fn into_storage(self) -> S {
3601        self.storage
3602    }
3603    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
3604        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3605            let offset = (0) as usize;
3606            let len = (1) as usize;
3607            core::result::Result::Ok((offset, len))
3608        })().unwrap_or((usize::MAX, 0));
3609        let storage = self.storage.slice(offset, len);
3610        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
3611    }
3612    pub fn starting_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3613        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3614            let offset = (1) as usize;
3615            let len = (2) as usize;
3616            core::result::Result::Ok((offset, len))
3617        })().unwrap_or((usize::MAX, 0));
3618        let storage = self.storage.slice(offset, len);
3619        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3620    }
3621    pub fn ending_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3622        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3623            let offset = (3) as usize;
3624            let len = (2) as usize;
3625            core::result::Result::Ok((offset, len))
3626        })().unwrap_or((usize::MAX, 0));
3627        let storage = self.storage.slice(offset, len);
3628        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3629    }
3630
3631}
3632
3633pub struct AttReadByGroupTypeReqHeaderMut<S: emboss_runtime::MutStorage> {
3634    storage: S,
3635}
3636
3637impl<S: emboss_runtime::MutStorage> AttReadByGroupTypeReqHeaderMut<S> {
3638    pub fn new(storage: S) -> Self {
3639        Self {
3640            storage,
3641        }
3642    }
3643    pub fn into_writer(self) -> AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3644        AttReadByGroupTypeReqHeaderWriter::new(self.storage)
3645    }
3646    /** Borrows the mutable view as an immutable view in UncheckedState. */
3647    pub fn as_view(&self) -> AttReadByGroupTypeReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
3648        unsafe { AttReadByGroupTypeReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
3649    }
3650    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
3651        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3652            let offset = (0) as usize;
3653            let len = (1) as usize;
3654            core::result::Result::Ok((offset, len))
3655        })().unwrap_or((usize::MAX, 0));
3656        let storage = self.storage.slice_mut(offset, len);
3657        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
3658    }
3659    pub fn starting_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3660        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3661            let offset = (1) as usize;
3662            let len = (2) as usize;
3663            core::result::Result::Ok((offset, len))
3664        })().unwrap_or((usize::MAX, 0));
3665        let storage = self.storage.slice_mut(offset, len);
3666        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3667    }
3668    pub fn ending_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3669        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3670            let offset = (3) as usize;
3671            let len = (2) as usize;
3672            core::result::Result::Ok((offset, len))
3673        })().unwrap_or((usize::MAX, 0));
3674        let storage = self.storage.slice_mut(offset, len);
3675        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3676    }
3677
3678}
3679
3680impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttReadByGroupTypeReqHeaderMut<S> {
3681    type Writer = AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::UncheckedState>;
3682    fn into_writer(self) -> Self::Writer {
3683        AttReadByGroupTypeReqHeaderWriter::new(self.storage)
3684    }
3685}
3686
3687pub struct AttReadByGroupTypeReqHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3688    storage: S,
3689    _marker: core::marker::PhantomData<ST>,
3690}
3691
3692impl<S: emboss_runtime::MutStorage> AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3693    pub fn new(storage: S) -> Self {
3694        Self {
3695            storage,
3696            _marker: core::marker::PhantomData,
3697        }
3698    }
3699}
3700
3701impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttReadByGroupTypeReqHeaderWriter<S, ST> {
3702    /**
3703     * Constructs a writer in a specific typestate.
3704     *
3705     * # Safety
3706     *
3707     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3708     */
3709    pub unsafe fn new_in_state(storage: S) -> Self {
3710        Self {
3711            storage,
3712            _marker: core::marker::PhantomData,
3713        }
3714    }
3715    pub fn into_storage(self) -> S {
3716        self.storage
3717    }
3718    /** Converts the writer into an immutable view in the same typestate. */
3719    pub fn into_view(self) -> AttReadByGroupTypeReqHeader<S, ST> {
3720        unsafe { AttReadByGroupTypeReqHeader::new_in_state(self.storage) }
3721    }
3722    /** Borrows the writer as an immutable view in the same typestate. */
3723    pub fn as_view(&self) -> AttReadByGroupTypeReqHeader<S::Sliced<'_>, ST> {
3724        unsafe { AttReadByGroupTypeReqHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
3725    }
3726    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttReadByGroupTypeReqHeaderWriter<S, ST::OnValidMutation> {
3727        let view = self.into_view();
3728        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3729            let offset = (0) as usize;
3730            let len = (1) as usize;
3731            core::result::Result::Ok((offset, len))
3732        })().expect("valid layout in complete state");
3733        let mut storage = view.into_storage();
3734        {
3735            let slice = storage.slice_mut(offset, len);
3736            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
3737            field_view.try_write(val).expect("valid write in complete state");
3738        }
3739        unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(storage) }
3740    }
3741    pub fn write_starting_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByGroupTypeReqHeaderWriter<S, ST::OnValidMutation> {
3742        let view = self.into_view();
3743        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3744            let offset = (1) as usize;
3745            let len = (2) as usize;
3746            core::result::Result::Ok((offset, len))
3747        })().expect("valid layout in complete state");
3748        let mut storage = view.into_storage();
3749        {
3750            let slice = storage.slice_mut(offset, len);
3751            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3752            field_view.try_write(val).expect("valid write in complete state");
3753        }
3754        unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(storage) }
3755    }
3756    pub fn write_ending_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByGroupTypeReqHeaderWriter<S, ST::OnValidMutation> {
3757        let view = self.into_view();
3758        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3759            let offset = (3) as usize;
3760            let len = (2) as usize;
3761            core::result::Result::Ok((offset, len))
3762        })().expect("valid layout in complete state");
3763        let mut storage = view.into_storage();
3764        {
3765            let slice = storage.slice_mut(offset, len);
3766            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
3767            field_view.try_write(val).expect("valid write in complete state");
3768        }
3769        unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(storage) }
3770    }
3771
3772}
3773
3774impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByGroupTypeReqHeader<S, ST> {
3775    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3776        let view = self;
3777        core::result::Result::Ok((5) as usize)
3778    }
3779}
3780
3781impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttReadByGroupTypeReqHeaderMut<S> {
3782    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3783        let view = self.as_view();
3784        <AttReadByGroupTypeReqHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
3785    }
3786}
3787
3788impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByGroupTypeReqHeaderWriter<S, ST> {
3789    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
3790        let view = self.as_view();
3791        <AttReadByGroupTypeReqHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
3792    }
3793}
3794
3795impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttReadByGroupTypeReqHeader<S, emboss_runtime::UncheckedState> {
3796    type Completed = AttReadByGroupTypeReqHeader<S, emboss_runtime::CompleteState>;
3797    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3798        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3799        if self.storage.len() < required_size {
3800            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3801        }
3802        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeader::new_in_state(self.storage) })
3803    }
3804}
3805
3806impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3807    type Completed = AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::CompleteState>;
3808    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
3809        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
3810        if self.storage.len() < required_size {
3811            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
3812        }
3813        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(self.storage) })
3814    }
3815}
3816
3817impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeader<S, emboss_runtime::UncheckedState> {
3818    type Ok = AttReadByGroupTypeReqHeader<S, emboss_runtime::OkState>;
3819    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3820        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3821        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeader::new_in_state(completed.into_storage()) })
3822    }
3823}
3824
3825impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeader<S, emboss_runtime::CompleteState> {
3826    type Ok = AttReadByGroupTypeReqHeader<S, emboss_runtime::OkState>;
3827    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3828        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeader::new_in_state(self.into_storage()) })
3829    }
3830}
3831
3832impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeader<S, emboss_runtime::OkState> {
3833    type Ok = AttReadByGroupTypeReqHeader<S, emboss_runtime::OkState>;
3834    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3835        core::result::Result::Ok(self)
3836    }
3837}
3838
3839impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::UncheckedState> {
3840    type Ok = AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3841    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3842        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
3843        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(completed.into_storage()) })
3844    }
3845}
3846
3847impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::CompleteState> {
3848    type Ok = AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3849    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3850        core::result::Result::Ok(unsafe { AttReadByGroupTypeReqHeaderWriter::new_in_state(self.into_storage()) })
3851    }
3852}
3853
3854impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::OkState> {
3855    type Ok = AttReadByGroupTypeReqHeaderWriter<S, emboss_runtime::OkState>;
3856    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
3857        core::result::Result::Ok(self)
3858    }
3859}
3860
3861pub mod att_read_by_group_type_req_header {
3862    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttReadByGroupTypeReqHeader<S, ST>;
3863    pub type ViewMut<S> = super::AttReadByGroupTypeReqHeaderMut<S>;
3864    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttReadByGroupTypeReqHeaderWriter<S, ST>;
3865
3866    pub const MIN_SIZE_IN_BYTES: usize = 5;
3867    pub const MAX_SIZE_IN_BYTES: usize = 5;
3868    pub const SIZE_IN_BYTES: usize = 5;
3869}pub struct AttReadByGroupTypeRspEntryHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3870    storage: S,
3871    _marker: core::marker::PhantomData<ST>,
3872}
3873
3874impl<S: emboss_runtime::Storage> AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::UncheckedState> {
3875    pub fn new(storage: S) -> Self {
3876        Self {
3877            storage,
3878            _marker: core::marker::PhantomData,
3879        }
3880    }
3881}
3882
3883impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttReadByGroupTypeRspEntryHeader<S, ST> {
3884    fn clone(&self) -> Self {
3885        Self {
3886            storage: self.storage.clone(),
3887            _marker: core::marker::PhantomData,
3888        }
3889    }
3890}
3891
3892impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttReadByGroupTypeRspEntryHeader<S, ST> {
3893    /**
3894     * Constructs a view in a specific typestate.
3895     *
3896     * # Safety
3897     *
3898     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3899     */
3900    pub unsafe fn new_in_state(storage: S) -> Self {
3901        Self {
3902            storage,
3903            _marker: core::marker::PhantomData,
3904        }
3905    }
3906    pub fn into_storage(self) -> S {
3907        self.storage
3908    }
3909    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3910        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3911            let offset = (0) as usize;
3912            let len = (2) as usize;
3913            core::result::Result::Ok((offset, len))
3914        })().unwrap_or((usize::MAX, 0));
3915        let storage = self.storage.slice(offset, len);
3916        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3917    }
3918    pub fn end_group_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
3919        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3920            let offset = (2) as usize;
3921            let len = (2) as usize;
3922            core::result::Result::Ok((offset, len))
3923        })().unwrap_or((usize::MAX, 0));
3924        let storage = self.storage.slice(offset, len);
3925        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
3926    }
3927
3928}
3929
3930pub struct AttReadByGroupTypeRspEntryHeaderMut<S: emboss_runtime::MutStorage> {
3931    storage: S,
3932}
3933
3934impl<S: emboss_runtime::MutStorage> AttReadByGroupTypeRspEntryHeaderMut<S> {
3935    pub fn new(storage: S) -> Self {
3936        Self {
3937            storage,
3938        }
3939    }
3940    pub fn into_writer(self) -> AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::UncheckedState> {
3941        AttReadByGroupTypeRspEntryHeaderWriter::new(self.storage)
3942    }
3943    /** Borrows the mutable view as an immutable view in UncheckedState. */
3944    pub fn as_view(&self) -> AttReadByGroupTypeRspEntryHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
3945        unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
3946    }
3947    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3948        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3949            let offset = (0) as usize;
3950            let len = (2) as usize;
3951            core::result::Result::Ok((offset, len))
3952        })().unwrap_or((usize::MAX, 0));
3953        let storage = self.storage.slice_mut(offset, len);
3954        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3955    }
3956    pub fn end_group_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
3957        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
3958            let offset = (2) as usize;
3959            let len = (2) as usize;
3960            core::result::Result::Ok((offset, len))
3961        })().unwrap_or((usize::MAX, 0));
3962        let storage = self.storage.slice_mut(offset, len);
3963        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
3964    }
3965
3966}
3967
3968impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttReadByGroupTypeRspEntryHeaderMut<S> {
3969    type Writer = AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::UncheckedState>;
3970    fn into_writer(self) -> Self::Writer {
3971        AttReadByGroupTypeRspEntryHeaderWriter::new(self.storage)
3972    }
3973}
3974
3975pub struct AttReadByGroupTypeRspEntryHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
3976    storage: S,
3977    _marker: core::marker::PhantomData<ST>,
3978}
3979
3980impl<S: emboss_runtime::MutStorage> AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::UncheckedState> {
3981    pub fn new(storage: S) -> Self {
3982        Self {
3983            storage,
3984            _marker: core::marker::PhantomData,
3985        }
3986    }
3987}
3988
3989impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttReadByGroupTypeRspEntryHeaderWriter<S, ST> {
3990    /**
3991     * Constructs a writer in a specific typestate.
3992     *
3993     * # Safety
3994     *
3995     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
3996     */
3997    pub unsafe fn new_in_state(storage: S) -> Self {
3998        Self {
3999            storage,
4000            _marker: core::marker::PhantomData,
4001        }
4002    }
4003    pub fn into_storage(self) -> S {
4004        self.storage
4005    }
4006    /** Converts the writer into an immutable view in the same typestate. */
4007    pub fn into_view(self) -> AttReadByGroupTypeRspEntryHeader<S, ST> {
4008        unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(self.storage) }
4009    }
4010    /** Borrows the writer as an immutable view in the same typestate. */
4011    pub fn as_view(&self) -> AttReadByGroupTypeRspEntryHeader<S::Sliced<'_>, ST> {
4012        unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
4013    }
4014    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByGroupTypeRspEntryHeaderWriter<S, ST::OnValidMutation> {
4015        let view = self.into_view();
4016        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4017            let offset = (0) as usize;
4018            let len = (2) as usize;
4019            core::result::Result::Ok((offset, len))
4020        })().expect("valid layout in complete state");
4021        let mut storage = view.into_storage();
4022        {
4023            let slice = storage.slice_mut(offset, len);
4024            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4025            field_view.try_write(val).expect("valid write in complete state");
4026        }
4027        unsafe { AttReadByGroupTypeRspEntryHeaderWriter::new_in_state(storage) }
4028    }
4029    pub fn write_end_group_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadByGroupTypeRspEntryHeaderWriter<S, ST::OnValidMutation> {
4030        let view = self.into_view();
4031        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4032            let offset = (2) as usize;
4033            let len = (2) as usize;
4034            core::result::Result::Ok((offset, len))
4035        })().expect("valid layout in complete state");
4036        let mut storage = view.into_storage();
4037        {
4038            let slice = storage.slice_mut(offset, len);
4039            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4040            field_view.try_write(val).expect("valid write in complete state");
4041        }
4042        unsafe { AttReadByGroupTypeRspEntryHeaderWriter::new_in_state(storage) }
4043    }
4044
4045}
4046
4047impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByGroupTypeRspEntryHeader<S, ST> {
4048    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4049        let view = self;
4050        core::result::Result::Ok((4) as usize)
4051    }
4052}
4053
4054impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttReadByGroupTypeRspEntryHeaderMut<S> {
4055    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4056        let view = self.as_view();
4057        <AttReadByGroupTypeRspEntryHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
4058    }
4059}
4060
4061impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttReadByGroupTypeRspEntryHeaderWriter<S, ST> {
4062    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4063        let view = self.as_view();
4064        <AttReadByGroupTypeRspEntryHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
4065    }
4066}
4067
4068impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::UncheckedState> {
4069    type Completed = AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::CompleteState>;
4070    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4071        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4072        if self.storage.len() < required_size {
4073            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4074        }
4075        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(self.storage) })
4076    }
4077}
4078
4079impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::UncheckedState> {
4080    type Completed = AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::CompleteState>;
4081    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4082        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4083        if self.storage.len() < required_size {
4084            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4085        }
4086        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeaderWriter::new_in_state(self.storage) })
4087    }
4088}
4089
4090impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::UncheckedState> {
4091    type Ok = AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::OkState>;
4092    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4093        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4094        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(completed.into_storage()) })
4095    }
4096}
4097
4098impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::CompleteState> {
4099    type Ok = AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::OkState>;
4100    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4101        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeader::new_in_state(self.into_storage()) })
4102    }
4103}
4104
4105impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::OkState> {
4106    type Ok = AttReadByGroupTypeRspEntryHeader<S, emboss_runtime::OkState>;
4107    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4108        core::result::Result::Ok(self)
4109    }
4110}
4111
4112impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::UncheckedState> {
4113    type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::OkState>;
4114    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4115        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4116        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeaderWriter::new_in_state(completed.into_storage()) })
4117    }
4118}
4119
4120impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::CompleteState> {
4121    type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::OkState>;
4122    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4123        core::result::Result::Ok(unsafe { AttReadByGroupTypeRspEntryHeaderWriter::new_in_state(self.into_storage()) })
4124    }
4125}
4126
4127impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::OkState> {
4128    type Ok = AttReadByGroupTypeRspEntryHeaderWriter<S, emboss_runtime::OkState>;
4129    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4130        core::result::Result::Ok(self)
4131    }
4132}
4133
4134pub mod att_read_by_group_type_rsp_entry_header {
4135    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttReadByGroupTypeRspEntryHeader<S, ST>;
4136    pub type ViewMut<S> = super::AttReadByGroupTypeRspEntryHeaderMut<S>;
4137    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttReadByGroupTypeRspEntryHeaderWriter<S, ST>;
4138
4139    pub const MIN_SIZE_IN_BYTES: usize = 4;
4140    pub const MAX_SIZE_IN_BYTES: usize = 4;
4141    pub const SIZE_IN_BYTES: usize = 4;
4142}pub struct AttReadReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4143    storage: S,
4144    _marker: core::marker::PhantomData<ST>,
4145}
4146
4147impl<S: emboss_runtime::Storage> AttReadReq<S, emboss_runtime::UncheckedState> {
4148    pub fn new(storage: S) -> Self {
4149        Self {
4150            storage,
4151            _marker: core::marker::PhantomData,
4152        }
4153    }
4154}
4155
4156impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttReadReq<S, ST> {
4157    fn clone(&self) -> Self {
4158        Self {
4159            storage: self.storage.clone(),
4160            _marker: core::marker::PhantomData,
4161        }
4162    }
4163}
4164
4165impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttReadReq<S, ST> {
4166    /**
4167     * Constructs a view in a specific typestate.
4168     *
4169     * # Safety
4170     *
4171     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4172     */
4173    pub unsafe fn new_in_state(storage: S) -> Self {
4174        Self {
4175            storage,
4176            _marker: core::marker::PhantomData,
4177        }
4178    }
4179    pub fn into_storage(self) -> S {
4180        self.storage
4181    }
4182    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
4183        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4184            let offset = (0) as usize;
4185            let len = (1) as usize;
4186            core::result::Result::Ok((offset, len))
4187        })().unwrap_or((usize::MAX, 0));
4188        let storage = self.storage.slice(offset, len);
4189        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
4190    }
4191    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
4192        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4193            let offset = (1) as usize;
4194            let len = (2) as usize;
4195            core::result::Result::Ok((offset, len))
4196        })().unwrap_or((usize::MAX, 0));
4197        let storage = self.storage.slice(offset, len);
4198        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
4199    }
4200
4201}
4202
4203pub struct AttReadReqMut<S: emboss_runtime::MutStorage> {
4204    storage: S,
4205}
4206
4207impl<S: emboss_runtime::MutStorage> AttReadReqMut<S> {
4208    pub fn new(storage: S) -> Self {
4209        Self {
4210            storage,
4211        }
4212    }
4213    pub fn into_writer(self) -> AttReadReqWriter<S, emboss_runtime::UncheckedState> {
4214        AttReadReqWriter::new(self.storage)
4215    }
4216    /** Borrows the mutable view as an immutable view in UncheckedState. */
4217    pub fn as_view(&self) -> AttReadReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
4218        unsafe { AttReadReq::new_in_state(self.storage.slice(0, self.storage.len())) }
4219    }
4220    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
4221        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4222            let offset = (0) as usize;
4223            let len = (1) as usize;
4224            core::result::Result::Ok((offset, len))
4225        })().unwrap_or((usize::MAX, 0));
4226        let storage = self.storage.slice_mut(offset, len);
4227        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
4228    }
4229    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
4230        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4231            let offset = (1) as usize;
4232            let len = (2) as usize;
4233            core::result::Result::Ok((offset, len))
4234        })().unwrap_or((usize::MAX, 0));
4235        let storage = self.storage.slice_mut(offset, len);
4236        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
4237    }
4238
4239}
4240
4241impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttReadReqMut<S> {
4242    type Writer = AttReadReqWriter<S, emboss_runtime::UncheckedState>;
4243    fn into_writer(self) -> Self::Writer {
4244        AttReadReqWriter::new(self.storage)
4245    }
4246}
4247
4248pub struct AttReadReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4249    storage: S,
4250    _marker: core::marker::PhantomData<ST>,
4251}
4252
4253impl<S: emboss_runtime::MutStorage> AttReadReqWriter<S, emboss_runtime::UncheckedState> {
4254    pub fn new(storage: S) -> Self {
4255        Self {
4256            storage,
4257            _marker: core::marker::PhantomData,
4258        }
4259    }
4260}
4261
4262impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttReadReqWriter<S, ST> {
4263    /**
4264     * Constructs a writer in a specific typestate.
4265     *
4266     * # Safety
4267     *
4268     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4269     */
4270    pub unsafe fn new_in_state(storage: S) -> Self {
4271        Self {
4272            storage,
4273            _marker: core::marker::PhantomData,
4274        }
4275    }
4276    pub fn into_storage(self) -> S {
4277        self.storage
4278    }
4279    /** Converts the writer into an immutable view in the same typestate. */
4280    pub fn into_view(self) -> AttReadReq<S, ST> {
4281        unsafe { AttReadReq::new_in_state(self.storage) }
4282    }
4283    /** Borrows the writer as an immutable view in the same typestate. */
4284    pub fn as_view(&self) -> AttReadReq<S::Sliced<'_>, ST> {
4285        unsafe { AttReadReq::new_in_state(self.storage.slice(0, self.storage.len())) }
4286    }
4287    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttReadReqWriter<S, ST::OnValidMutation> {
4288        let view = self.into_view();
4289        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4290            let offset = (0) as usize;
4291            let len = (1) as usize;
4292            core::result::Result::Ok((offset, len))
4293        })().expect("valid layout in complete state");
4294        let mut storage = view.into_storage();
4295        {
4296            let slice = storage.slice_mut(offset, len);
4297            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
4298            field_view.try_write(val).expect("valid write in complete state");
4299        }
4300        unsafe { AttReadReqWriter::new_in_state(storage) }
4301    }
4302    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadReqWriter<S, ST::OnValidMutation> {
4303        let view = self.into_view();
4304        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4305            let offset = (1) as usize;
4306            let len = (2) as usize;
4307            core::result::Result::Ok((offset, len))
4308        })().expect("valid layout in complete state");
4309        let mut storage = view.into_storage();
4310        {
4311            let slice = storage.slice_mut(offset, len);
4312            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4313            field_view.try_write(val).expect("valid write in complete state");
4314        }
4315        unsafe { AttReadReqWriter::new_in_state(storage) }
4316    }
4317
4318}
4319
4320impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttReadReq<S, ST> {
4321    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4322        let view = self;
4323        core::result::Result::Ok((3) as usize)
4324    }
4325}
4326
4327impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttReadReqMut<S> {
4328    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4329        let view = self.as_view();
4330        <AttReadReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
4331    }
4332}
4333
4334impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttReadReqWriter<S, ST> {
4335    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4336        let view = self.as_view();
4337        <AttReadReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
4338    }
4339}
4340
4341impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttReadReq<S, emboss_runtime::UncheckedState> {
4342    type Completed = AttReadReq<S, emboss_runtime::CompleteState>;
4343    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4344        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4345        if self.storage.len() < required_size {
4346            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4347        }
4348        core::result::Result::Ok(unsafe { AttReadReq::new_in_state(self.storage) })
4349    }
4350}
4351
4352impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttReadReqWriter<S, emboss_runtime::UncheckedState> {
4353    type Completed = AttReadReqWriter<S, emboss_runtime::CompleteState>;
4354    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4355        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4356        if self.storage.len() < required_size {
4357            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4358        }
4359        core::result::Result::Ok(unsafe { AttReadReqWriter::new_in_state(self.storage) })
4360    }
4361}
4362
4363impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadReq<S, emboss_runtime::UncheckedState> {
4364    type Ok = AttReadReq<S, emboss_runtime::OkState>;
4365    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4366        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4367        core::result::Result::Ok(unsafe { AttReadReq::new_in_state(completed.into_storage()) })
4368    }
4369}
4370
4371impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadReq<S, emboss_runtime::CompleteState> {
4372    type Ok = AttReadReq<S, emboss_runtime::OkState>;
4373    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4374        core::result::Result::Ok(unsafe { AttReadReq::new_in_state(self.into_storage()) })
4375    }
4376}
4377
4378impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadReq<S, emboss_runtime::OkState> {
4379    type Ok = AttReadReq<S, emboss_runtime::OkState>;
4380    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4381        core::result::Result::Ok(self)
4382    }
4383}
4384
4385impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadReqWriter<S, emboss_runtime::UncheckedState> {
4386    type Ok = AttReadReqWriter<S, emboss_runtime::OkState>;
4387    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4388        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4389        core::result::Result::Ok(unsafe { AttReadReqWriter::new_in_state(completed.into_storage()) })
4390    }
4391}
4392
4393impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadReqWriter<S, emboss_runtime::CompleteState> {
4394    type Ok = AttReadReqWriter<S, emboss_runtime::OkState>;
4395    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4396        core::result::Result::Ok(unsafe { AttReadReqWriter::new_in_state(self.into_storage()) })
4397    }
4398}
4399
4400impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadReqWriter<S, emboss_runtime::OkState> {
4401    type Ok = AttReadReqWriter<S, emboss_runtime::OkState>;
4402    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4403        core::result::Result::Ok(self)
4404    }
4405}
4406
4407pub mod att_read_req {
4408    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttReadReq<S, ST>;
4409    pub type ViewMut<S> = super::AttReadReqMut<S>;
4410    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttReadReqWriter<S, ST>;
4411
4412    pub const MIN_SIZE_IN_BYTES: usize = 3;
4413    pub const MAX_SIZE_IN_BYTES: usize = 3;
4414    pub const SIZE_IN_BYTES: usize = 3;
4415}pub struct AttReadBlobReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4416    storage: S,
4417    _marker: core::marker::PhantomData<ST>,
4418}
4419
4420impl<S: emboss_runtime::Storage> AttReadBlobReq<S, emboss_runtime::UncheckedState> {
4421    pub fn new(storage: S) -> Self {
4422        Self {
4423            storage,
4424            _marker: core::marker::PhantomData,
4425        }
4426    }
4427}
4428
4429impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttReadBlobReq<S, ST> {
4430    fn clone(&self) -> Self {
4431        Self {
4432            storage: self.storage.clone(),
4433            _marker: core::marker::PhantomData,
4434        }
4435    }
4436}
4437
4438impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttReadBlobReq<S, ST> {
4439    /**
4440     * Constructs a view in a specific typestate.
4441     *
4442     * # Safety
4443     *
4444     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4445     */
4446    pub unsafe fn new_in_state(storage: S) -> Self {
4447        Self {
4448            storage,
4449            _marker: core::marker::PhantomData,
4450        }
4451    }
4452    pub fn into_storage(self) -> S {
4453        self.storage
4454    }
4455    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
4456        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4457            let offset = (0) as usize;
4458            let len = (1) as usize;
4459            core::result::Result::Ok((offset, len))
4460        })().unwrap_or((usize::MAX, 0));
4461        let storage = self.storage.slice(offset, len);
4462        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
4463    }
4464    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
4465        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4466            let offset = (1) as usize;
4467            let len = (2) as usize;
4468            core::result::Result::Ok((offset, len))
4469        })().unwrap_or((usize::MAX, 0));
4470        let storage = self.storage.slice(offset, len);
4471        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
4472    }
4473    pub fn value_offset(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
4474        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4475            let offset = (3) as usize;
4476            let len = (2) as usize;
4477            core::result::Result::Ok((offset, len))
4478        })().unwrap_or((usize::MAX, 0));
4479        let storage = self.storage.slice(offset, len);
4480        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
4481    }
4482
4483}
4484
4485pub struct AttReadBlobReqMut<S: emboss_runtime::MutStorage> {
4486    storage: S,
4487}
4488
4489impl<S: emboss_runtime::MutStorage> AttReadBlobReqMut<S> {
4490    pub fn new(storage: S) -> Self {
4491        Self {
4492            storage,
4493        }
4494    }
4495    pub fn into_writer(self) -> AttReadBlobReqWriter<S, emboss_runtime::UncheckedState> {
4496        AttReadBlobReqWriter::new(self.storage)
4497    }
4498    /** Borrows the mutable view as an immutable view in UncheckedState. */
4499    pub fn as_view(&self) -> AttReadBlobReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
4500        unsafe { AttReadBlobReq::new_in_state(self.storage.slice(0, self.storage.len())) }
4501    }
4502    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
4503        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4504            let offset = (0) as usize;
4505            let len = (1) as usize;
4506            core::result::Result::Ok((offset, len))
4507        })().unwrap_or((usize::MAX, 0));
4508        let storage = self.storage.slice_mut(offset, len);
4509        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
4510    }
4511    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
4512        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4513            let offset = (1) as usize;
4514            let len = (2) as usize;
4515            core::result::Result::Ok((offset, len))
4516        })().unwrap_or((usize::MAX, 0));
4517        let storage = self.storage.slice_mut(offset, len);
4518        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
4519    }
4520    pub fn value_offset(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
4521        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4522            let offset = (3) as usize;
4523            let len = (2) as usize;
4524            core::result::Result::Ok((offset, len))
4525        })().unwrap_or((usize::MAX, 0));
4526        let storage = self.storage.slice_mut(offset, len);
4527        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
4528    }
4529
4530}
4531
4532impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttReadBlobReqMut<S> {
4533    type Writer = AttReadBlobReqWriter<S, emboss_runtime::UncheckedState>;
4534    fn into_writer(self) -> Self::Writer {
4535        AttReadBlobReqWriter::new(self.storage)
4536    }
4537}
4538
4539pub struct AttReadBlobReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4540    storage: S,
4541    _marker: core::marker::PhantomData<ST>,
4542}
4543
4544impl<S: emboss_runtime::MutStorage> AttReadBlobReqWriter<S, emboss_runtime::UncheckedState> {
4545    pub fn new(storage: S) -> Self {
4546        Self {
4547            storage,
4548            _marker: core::marker::PhantomData,
4549        }
4550    }
4551}
4552
4553impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttReadBlobReqWriter<S, ST> {
4554    /**
4555     * Constructs a writer in a specific typestate.
4556     *
4557     * # Safety
4558     *
4559     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4560     */
4561    pub unsafe fn new_in_state(storage: S) -> Self {
4562        Self {
4563            storage,
4564            _marker: core::marker::PhantomData,
4565        }
4566    }
4567    pub fn into_storage(self) -> S {
4568        self.storage
4569    }
4570    /** Converts the writer into an immutable view in the same typestate. */
4571    pub fn into_view(self) -> AttReadBlobReq<S, ST> {
4572        unsafe { AttReadBlobReq::new_in_state(self.storage) }
4573    }
4574    /** Borrows the writer as an immutable view in the same typestate. */
4575    pub fn as_view(&self) -> AttReadBlobReq<S::Sliced<'_>, ST> {
4576        unsafe { AttReadBlobReq::new_in_state(self.storage.slice(0, self.storage.len())) }
4577    }
4578    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttReadBlobReqWriter<S, ST::OnValidMutation> {
4579        let view = self.into_view();
4580        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4581            let offset = (0) as usize;
4582            let len = (1) as usize;
4583            core::result::Result::Ok((offset, len))
4584        })().expect("valid layout in complete state");
4585        let mut storage = view.into_storage();
4586        {
4587            let slice = storage.slice_mut(offset, len);
4588            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
4589            field_view.try_write(val).expect("valid write in complete state");
4590        }
4591        unsafe { AttReadBlobReqWriter::new_in_state(storage) }
4592    }
4593    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadBlobReqWriter<S, ST::OnValidMutation> {
4594        let view = self.into_view();
4595        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4596            let offset = (1) as usize;
4597            let len = (2) as usize;
4598            core::result::Result::Ok((offset, len))
4599        })().expect("valid layout in complete state");
4600        let mut storage = view.into_storage();
4601        {
4602            let slice = storage.slice_mut(offset, len);
4603            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4604            field_view.try_write(val).expect("valid write in complete state");
4605        }
4606        unsafe { AttReadBlobReqWriter::new_in_state(storage) }
4607    }
4608    pub fn write_value_offset(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttReadBlobReqWriter<S, ST::OnValidMutation> {
4609        let view = self.into_view();
4610        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4611            let offset = (3) as usize;
4612            let len = (2) as usize;
4613            core::result::Result::Ok((offset, len))
4614        })().expect("valid layout in complete state");
4615        let mut storage = view.into_storage();
4616        {
4617            let slice = storage.slice_mut(offset, len);
4618            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4619            field_view.try_write(val).expect("valid write in complete state");
4620        }
4621        unsafe { AttReadBlobReqWriter::new_in_state(storage) }
4622    }
4623
4624}
4625
4626impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttReadBlobReq<S, ST> {
4627    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4628        let view = self;
4629        core::result::Result::Ok((5) as usize)
4630    }
4631}
4632
4633impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttReadBlobReqMut<S> {
4634    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4635        let view = self.as_view();
4636        <AttReadBlobReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
4637    }
4638}
4639
4640impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttReadBlobReqWriter<S, ST> {
4641    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4642        let view = self.as_view();
4643        <AttReadBlobReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
4644    }
4645}
4646
4647impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttReadBlobReq<S, emboss_runtime::UncheckedState> {
4648    type Completed = AttReadBlobReq<S, emboss_runtime::CompleteState>;
4649    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4650        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4651        if self.storage.len() < required_size {
4652            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4653        }
4654        core::result::Result::Ok(unsafe { AttReadBlobReq::new_in_state(self.storage) })
4655    }
4656}
4657
4658impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttReadBlobReqWriter<S, emboss_runtime::UncheckedState> {
4659    type Completed = AttReadBlobReqWriter<S, emboss_runtime::CompleteState>;
4660    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4661        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4662        if self.storage.len() < required_size {
4663            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4664        }
4665        core::result::Result::Ok(unsafe { AttReadBlobReqWriter::new_in_state(self.storage) })
4666    }
4667}
4668
4669impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadBlobReq<S, emboss_runtime::UncheckedState> {
4670    type Ok = AttReadBlobReq<S, emboss_runtime::OkState>;
4671    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4672        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4673        core::result::Result::Ok(unsafe { AttReadBlobReq::new_in_state(completed.into_storage()) })
4674    }
4675}
4676
4677impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadBlobReq<S, emboss_runtime::CompleteState> {
4678    type Ok = AttReadBlobReq<S, emboss_runtime::OkState>;
4679    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4680        core::result::Result::Ok(unsafe { AttReadBlobReq::new_in_state(self.into_storage()) })
4681    }
4682}
4683
4684impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttReadBlobReq<S, emboss_runtime::OkState> {
4685    type Ok = AttReadBlobReq<S, emboss_runtime::OkState>;
4686    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4687        core::result::Result::Ok(self)
4688    }
4689}
4690
4691impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadBlobReqWriter<S, emboss_runtime::UncheckedState> {
4692    type Ok = AttReadBlobReqWriter<S, emboss_runtime::OkState>;
4693    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4694        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4695        core::result::Result::Ok(unsafe { AttReadBlobReqWriter::new_in_state(completed.into_storage()) })
4696    }
4697}
4698
4699impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadBlobReqWriter<S, emboss_runtime::CompleteState> {
4700    type Ok = AttReadBlobReqWriter<S, emboss_runtime::OkState>;
4701    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4702        core::result::Result::Ok(unsafe { AttReadBlobReqWriter::new_in_state(self.into_storage()) })
4703    }
4704}
4705
4706impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttReadBlobReqWriter<S, emboss_runtime::OkState> {
4707    type Ok = AttReadBlobReqWriter<S, emboss_runtime::OkState>;
4708    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4709        core::result::Result::Ok(self)
4710    }
4711}
4712
4713pub mod att_read_blob_req {
4714    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttReadBlobReq<S, ST>;
4715    pub type ViewMut<S> = super::AttReadBlobReqMut<S>;
4716    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttReadBlobReqWriter<S, ST>;
4717
4718    pub const MIN_SIZE_IN_BYTES: usize = 5;
4719    pub const MAX_SIZE_IN_BYTES: usize = 5;
4720    pub const SIZE_IN_BYTES: usize = 5;
4721}pub struct AttWriteCmd<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4722    storage: S,
4723    _marker: core::marker::PhantomData<ST>,
4724}
4725
4726impl<S: emboss_runtime::Storage> AttWriteCmd<S, emboss_runtime::UncheckedState> {
4727    pub fn new(storage: S) -> Self {
4728        Self {
4729            storage,
4730            _marker: core::marker::PhantomData,
4731        }
4732    }
4733}
4734
4735impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttWriteCmd<S, ST> {
4736    fn clone(&self) -> Self {
4737        Self {
4738            storage: self.storage.clone(),
4739            _marker: core::marker::PhantomData,
4740        }
4741    }
4742}
4743
4744impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttWriteCmd<S, ST> {
4745    /**
4746     * Constructs a view in a specific typestate.
4747     *
4748     * # Safety
4749     *
4750     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4751     */
4752    pub unsafe fn new_in_state(storage: S) -> Self {
4753        Self {
4754            storage,
4755            _marker: core::marker::PhantomData,
4756        }
4757    }
4758    pub fn into_storage(self) -> S {
4759        self.storage
4760    }
4761    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
4762        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4763            let offset = (0) as usize;
4764            let len = (1) as usize;
4765            core::result::Result::Ok((offset, len))
4766        })().unwrap_or((usize::MAX, 0));
4767        let storage = self.storage.slice(offset, len);
4768        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
4769    }
4770    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
4771        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4772            let offset = (1) as usize;
4773            let len = (2) as usize;
4774            core::result::Result::Ok((offset, len))
4775        })().unwrap_or((usize::MAX, 0));
4776        let storage = self.storage.slice(offset, len);
4777        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
4778    }
4779
4780}
4781
4782pub struct AttWriteCmdMut<S: emboss_runtime::MutStorage> {
4783    storage: S,
4784}
4785
4786impl<S: emboss_runtime::MutStorage> AttWriteCmdMut<S> {
4787    pub fn new(storage: S) -> Self {
4788        Self {
4789            storage,
4790        }
4791    }
4792    pub fn into_writer(self) -> AttWriteCmdWriter<S, emboss_runtime::UncheckedState> {
4793        AttWriteCmdWriter::new(self.storage)
4794    }
4795    /** Borrows the mutable view as an immutable view in UncheckedState. */
4796    pub fn as_view(&self) -> AttWriteCmd<S::Sliced<'_>, emboss_runtime::UncheckedState> {
4797        unsafe { AttWriteCmd::new_in_state(self.storage.slice(0, self.storage.len())) }
4798    }
4799    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
4800        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4801            let offset = (0) as usize;
4802            let len = (1) as usize;
4803            core::result::Result::Ok((offset, len))
4804        })().unwrap_or((usize::MAX, 0));
4805        let storage = self.storage.slice_mut(offset, len);
4806        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
4807    }
4808    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
4809        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4810            let offset = (1) as usize;
4811            let len = (2) as usize;
4812            core::result::Result::Ok((offset, len))
4813        })().unwrap_or((usize::MAX, 0));
4814        let storage = self.storage.slice_mut(offset, len);
4815        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
4816    }
4817
4818}
4819
4820impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttWriteCmdMut<S> {
4821    type Writer = AttWriteCmdWriter<S, emboss_runtime::UncheckedState>;
4822    fn into_writer(self) -> Self::Writer {
4823        AttWriteCmdWriter::new(self.storage)
4824    }
4825}
4826
4827pub struct AttWriteCmdWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4828    storage: S,
4829    _marker: core::marker::PhantomData<ST>,
4830}
4831
4832impl<S: emboss_runtime::MutStorage> AttWriteCmdWriter<S, emboss_runtime::UncheckedState> {
4833    pub fn new(storage: S) -> Self {
4834        Self {
4835            storage,
4836            _marker: core::marker::PhantomData,
4837        }
4838    }
4839}
4840
4841impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttWriteCmdWriter<S, ST> {
4842    /**
4843     * Constructs a writer in a specific typestate.
4844     *
4845     * # Safety
4846     *
4847     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
4848     */
4849    pub unsafe fn new_in_state(storage: S) -> Self {
4850        Self {
4851            storage,
4852            _marker: core::marker::PhantomData,
4853        }
4854    }
4855    pub fn into_storage(self) -> S {
4856        self.storage
4857    }
4858    /** Converts the writer into an immutable view in the same typestate. */
4859    pub fn into_view(self) -> AttWriteCmd<S, ST> {
4860        unsafe { AttWriteCmd::new_in_state(self.storage) }
4861    }
4862    /** Borrows the writer as an immutable view in the same typestate. */
4863    pub fn as_view(&self) -> AttWriteCmd<S::Sliced<'_>, ST> {
4864        unsafe { AttWriteCmd::new_in_state(self.storage.slice(0, self.storage.len())) }
4865    }
4866    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttWriteCmdWriter<S, ST::OnValidMutation> {
4867        let view = self.into_view();
4868        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4869            let offset = (0) as usize;
4870            let len = (1) as usize;
4871            core::result::Result::Ok((offset, len))
4872        })().expect("valid layout in complete state");
4873        let mut storage = view.into_storage();
4874        {
4875            let slice = storage.slice_mut(offset, len);
4876            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
4877            field_view.try_write(val).expect("valid write in complete state");
4878        }
4879        unsafe { AttWriteCmdWriter::new_in_state(storage) }
4880    }
4881    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttWriteCmdWriter<S, ST::OnValidMutation> {
4882        let view = self.into_view();
4883        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
4884            let offset = (1) as usize;
4885            let len = (2) as usize;
4886            core::result::Result::Ok((offset, len))
4887        })().expect("valid layout in complete state");
4888        let mut storage = view.into_storage();
4889        {
4890            let slice = storage.slice_mut(offset, len);
4891            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
4892            field_view.try_write(val).expect("valid write in complete state");
4893        }
4894        unsafe { AttWriteCmdWriter::new_in_state(storage) }
4895    }
4896
4897}
4898
4899impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttWriteCmd<S, ST> {
4900    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4901        let view = self;
4902        core::result::Result::Ok((0) as usize)
4903    }
4904}
4905
4906impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttWriteCmdMut<S> {
4907    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4908        let view = self.as_view();
4909        <AttWriteCmd<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
4910    }
4911}
4912
4913impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttWriteCmdWriter<S, ST> {
4914    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
4915        let view = self.as_view();
4916        <AttWriteCmd<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
4917    }
4918}
4919
4920impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttWriteCmd<S, emboss_runtime::UncheckedState> {
4921    type Completed = AttWriteCmd<S, emboss_runtime::CompleteState>;
4922    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4923        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4924        if self.storage.len() < required_size {
4925            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4926        }
4927        core::result::Result::Ok(unsafe { AttWriteCmd::new_in_state(self.storage) })
4928    }
4929}
4930
4931impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttWriteCmdWriter<S, emboss_runtime::UncheckedState> {
4932    type Completed = AttWriteCmdWriter<S, emboss_runtime::CompleteState>;
4933    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
4934        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
4935        if self.storage.len() < required_size {
4936            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
4937        }
4938        core::result::Result::Ok(unsafe { AttWriteCmdWriter::new_in_state(self.storage) })
4939    }
4940}
4941
4942impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttWriteCmd<S, emboss_runtime::UncheckedState> {
4943    type Ok = AttWriteCmd<S, emboss_runtime::OkState>;
4944    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4945        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4946        core::result::Result::Ok(unsafe { AttWriteCmd::new_in_state(completed.into_storage()) })
4947    }
4948}
4949
4950impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttWriteCmd<S, emboss_runtime::CompleteState> {
4951    type Ok = AttWriteCmd<S, emboss_runtime::OkState>;
4952    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4953        core::result::Result::Ok(unsafe { AttWriteCmd::new_in_state(self.into_storage()) })
4954    }
4955}
4956
4957impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttWriteCmd<S, emboss_runtime::OkState> {
4958    type Ok = AttWriteCmd<S, emboss_runtime::OkState>;
4959    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4960        core::result::Result::Ok(self)
4961    }
4962}
4963
4964impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttWriteCmdWriter<S, emboss_runtime::UncheckedState> {
4965    type Ok = AttWriteCmdWriter<S, emboss_runtime::OkState>;
4966    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4967        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
4968        core::result::Result::Ok(unsafe { AttWriteCmdWriter::new_in_state(completed.into_storage()) })
4969    }
4970}
4971
4972impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttWriteCmdWriter<S, emboss_runtime::CompleteState> {
4973    type Ok = AttWriteCmdWriter<S, emboss_runtime::OkState>;
4974    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4975        core::result::Result::Ok(unsafe { AttWriteCmdWriter::new_in_state(self.into_storage()) })
4976    }
4977}
4978
4979impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttWriteCmdWriter<S, emboss_runtime::OkState> {
4980    type Ok = AttWriteCmdWriter<S, emboss_runtime::OkState>;
4981    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
4982        core::result::Result::Ok(self)
4983    }
4984}
4985
4986pub mod att_write_cmd {
4987    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttWriteCmd<S, ST>;
4988    pub type ViewMut<S> = super::AttWriteCmdMut<S>;
4989    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttWriteCmdWriter<S, ST>;
4990
4991    pub const MIN_SIZE_IN_BYTES: usize = 3;
4992    pub const MAX_SIZE_IN_BYTES: usize = 65538;
4993}pub struct AttPrepareWriteHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
4994    storage: S,
4995    _marker: core::marker::PhantomData<ST>,
4996}
4997
4998impl<S: emboss_runtime::Storage> AttPrepareWriteHeader<S, emboss_runtime::UncheckedState> {
4999    pub fn new(storage: S) -> Self {
5000        Self {
5001            storage,
5002            _marker: core::marker::PhantomData,
5003        }
5004    }
5005}
5006
5007impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttPrepareWriteHeader<S, ST> {
5008    fn clone(&self) -> Self {
5009        Self {
5010            storage: self.storage.clone(),
5011            _marker: core::marker::PhantomData,
5012        }
5013    }
5014}
5015
5016impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttPrepareWriteHeader<S, ST> {
5017    /**
5018     * Constructs a view in a specific typestate.
5019     *
5020     * # Safety
5021     *
5022     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5023     */
5024    pub unsafe fn new_in_state(storage: S) -> Self {
5025        Self {
5026            storage,
5027            _marker: core::marker::PhantomData,
5028        }
5029    }
5030    pub fn into_storage(self) -> S {
5031        self.storage
5032    }
5033    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
5034        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5035            let offset = (0) as usize;
5036            let len = (1) as usize;
5037            core::result::Result::Ok((offset, len))
5038        })().unwrap_or((usize::MAX, 0));
5039        let storage = self.storage.slice(offset, len);
5040        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
5041    }
5042    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
5043        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5044            let offset = (1) as usize;
5045            let len = (2) as usize;
5046            core::result::Result::Ok((offset, len))
5047        })().unwrap_or((usize::MAX, 0));
5048        let storage = self.storage.slice(offset, len);
5049        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
5050    }
5051    pub fn value_offset(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
5052        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5053            let offset = (3) as usize;
5054            let len = (2) as usize;
5055            core::result::Result::Ok((offset, len))
5056        })().unwrap_or((usize::MAX, 0));
5057        let storage = self.storage.slice(offset, len);
5058        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
5059    }
5060
5061}
5062
5063pub struct AttPrepareWriteHeaderMut<S: emboss_runtime::MutStorage> {
5064    storage: S,
5065}
5066
5067impl<S: emboss_runtime::MutStorage> AttPrepareWriteHeaderMut<S> {
5068    pub fn new(storage: S) -> Self {
5069        Self {
5070            storage,
5071        }
5072    }
5073    pub fn into_writer(self) -> AttPrepareWriteHeaderWriter<S, emboss_runtime::UncheckedState> {
5074        AttPrepareWriteHeaderWriter::new(self.storage)
5075    }
5076    /** Borrows the mutable view as an immutable view in UncheckedState. */
5077    pub fn as_view(&self) -> AttPrepareWriteHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
5078        unsafe { AttPrepareWriteHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
5079    }
5080    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
5081        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5082            let offset = (0) as usize;
5083            let len = (1) as usize;
5084            core::result::Result::Ok((offset, len))
5085        })().unwrap_or((usize::MAX, 0));
5086        let storage = self.storage.slice_mut(offset, len);
5087        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
5088    }
5089    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
5090        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5091            let offset = (1) as usize;
5092            let len = (2) as usize;
5093            core::result::Result::Ok((offset, len))
5094        })().unwrap_or((usize::MAX, 0));
5095        let storage = self.storage.slice_mut(offset, len);
5096        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
5097    }
5098    pub fn value_offset(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
5099        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5100            let offset = (3) as usize;
5101            let len = (2) as usize;
5102            core::result::Result::Ok((offset, len))
5103        })().unwrap_or((usize::MAX, 0));
5104        let storage = self.storage.slice_mut(offset, len);
5105        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
5106    }
5107
5108}
5109
5110impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttPrepareWriteHeaderMut<S> {
5111    type Writer = AttPrepareWriteHeaderWriter<S, emboss_runtime::UncheckedState>;
5112    fn into_writer(self) -> Self::Writer {
5113        AttPrepareWriteHeaderWriter::new(self.storage)
5114    }
5115}
5116
5117pub struct AttPrepareWriteHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5118    storage: S,
5119    _marker: core::marker::PhantomData<ST>,
5120}
5121
5122impl<S: emboss_runtime::MutStorage> AttPrepareWriteHeaderWriter<S, emboss_runtime::UncheckedState> {
5123    pub fn new(storage: S) -> Self {
5124        Self {
5125            storage,
5126            _marker: core::marker::PhantomData,
5127        }
5128    }
5129}
5130
5131impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttPrepareWriteHeaderWriter<S, ST> {
5132    /**
5133     * Constructs a writer in a specific typestate.
5134     *
5135     * # Safety
5136     *
5137     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5138     */
5139    pub unsafe fn new_in_state(storage: S) -> Self {
5140        Self {
5141            storage,
5142            _marker: core::marker::PhantomData,
5143        }
5144    }
5145    pub fn into_storage(self) -> S {
5146        self.storage
5147    }
5148    /** Converts the writer into an immutable view in the same typestate. */
5149    pub fn into_view(self) -> AttPrepareWriteHeader<S, ST> {
5150        unsafe { AttPrepareWriteHeader::new_in_state(self.storage) }
5151    }
5152    /** Borrows the writer as an immutable view in the same typestate. */
5153    pub fn as_view(&self) -> AttPrepareWriteHeader<S::Sliced<'_>, ST> {
5154        unsafe { AttPrepareWriteHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
5155    }
5156    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttPrepareWriteHeaderWriter<S, ST::OnValidMutation> {
5157        let view = self.into_view();
5158        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5159            let offset = (0) as usize;
5160            let len = (1) as usize;
5161            core::result::Result::Ok((offset, len))
5162        })().expect("valid layout in complete state");
5163        let mut storage = view.into_storage();
5164        {
5165            let slice = storage.slice_mut(offset, len);
5166            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
5167            field_view.try_write(val).expect("valid write in complete state");
5168        }
5169        unsafe { AttPrepareWriteHeaderWriter::new_in_state(storage) }
5170    }
5171    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttPrepareWriteHeaderWriter<S, ST::OnValidMutation> {
5172        let view = self.into_view();
5173        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5174            let offset = (1) as usize;
5175            let len = (2) as usize;
5176            core::result::Result::Ok((offset, len))
5177        })().expect("valid layout in complete state");
5178        let mut storage = view.into_storage();
5179        {
5180            let slice = storage.slice_mut(offset, len);
5181            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
5182            field_view.try_write(val).expect("valid write in complete state");
5183        }
5184        unsafe { AttPrepareWriteHeaderWriter::new_in_state(storage) }
5185    }
5186    pub fn write_value_offset(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttPrepareWriteHeaderWriter<S, ST::OnValidMutation> {
5187        let view = self.into_view();
5188        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5189            let offset = (3) as usize;
5190            let len = (2) as usize;
5191            core::result::Result::Ok((offset, len))
5192        })().expect("valid layout in complete state");
5193        let mut storage = view.into_storage();
5194        {
5195            let slice = storage.slice_mut(offset, len);
5196            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
5197            field_view.try_write(val).expect("valid write in complete state");
5198        }
5199        unsafe { AttPrepareWriteHeaderWriter::new_in_state(storage) }
5200    }
5201
5202}
5203
5204impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttPrepareWriteHeader<S, ST> {
5205    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5206        let view = self;
5207        core::result::Result::Ok((5) as usize)
5208    }
5209}
5210
5211impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttPrepareWriteHeaderMut<S> {
5212    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5213        let view = self.as_view();
5214        <AttPrepareWriteHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
5215    }
5216}
5217
5218impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttPrepareWriteHeaderWriter<S, ST> {
5219    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5220        let view = self.as_view();
5221        <AttPrepareWriteHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
5222    }
5223}
5224
5225impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttPrepareWriteHeader<S, emboss_runtime::UncheckedState> {
5226    type Completed = AttPrepareWriteHeader<S, emboss_runtime::CompleteState>;
5227    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5228        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5229        if self.storage.len() < required_size {
5230            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5231        }
5232        core::result::Result::Ok(unsafe { AttPrepareWriteHeader::new_in_state(self.storage) })
5233    }
5234}
5235
5236impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttPrepareWriteHeaderWriter<S, emboss_runtime::UncheckedState> {
5237    type Completed = AttPrepareWriteHeaderWriter<S, emboss_runtime::CompleteState>;
5238    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5239        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5240        if self.storage.len() < required_size {
5241            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5242        }
5243        core::result::Result::Ok(unsafe { AttPrepareWriteHeaderWriter::new_in_state(self.storage) })
5244    }
5245}
5246
5247impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttPrepareWriteHeader<S, emboss_runtime::UncheckedState> {
5248    type Ok = AttPrepareWriteHeader<S, emboss_runtime::OkState>;
5249    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5250        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5251        core::result::Result::Ok(unsafe { AttPrepareWriteHeader::new_in_state(completed.into_storage()) })
5252    }
5253}
5254
5255impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttPrepareWriteHeader<S, emboss_runtime::CompleteState> {
5256    type Ok = AttPrepareWriteHeader<S, emboss_runtime::OkState>;
5257    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5258        core::result::Result::Ok(unsafe { AttPrepareWriteHeader::new_in_state(self.into_storage()) })
5259    }
5260}
5261
5262impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttPrepareWriteHeader<S, emboss_runtime::OkState> {
5263    type Ok = AttPrepareWriteHeader<S, emboss_runtime::OkState>;
5264    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5265        core::result::Result::Ok(self)
5266    }
5267}
5268
5269impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttPrepareWriteHeaderWriter<S, emboss_runtime::UncheckedState> {
5270    type Ok = AttPrepareWriteHeaderWriter<S, emboss_runtime::OkState>;
5271    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5272        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5273        core::result::Result::Ok(unsafe { AttPrepareWriteHeaderWriter::new_in_state(completed.into_storage()) })
5274    }
5275}
5276
5277impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttPrepareWriteHeaderWriter<S, emboss_runtime::CompleteState> {
5278    type Ok = AttPrepareWriteHeaderWriter<S, emboss_runtime::OkState>;
5279    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5280        core::result::Result::Ok(unsafe { AttPrepareWriteHeaderWriter::new_in_state(self.into_storage()) })
5281    }
5282}
5283
5284impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttPrepareWriteHeaderWriter<S, emboss_runtime::OkState> {
5285    type Ok = AttPrepareWriteHeaderWriter<S, emboss_runtime::OkState>;
5286    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5287        core::result::Result::Ok(self)
5288    }
5289}
5290
5291pub mod att_prepare_write_header {
5292    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttPrepareWriteHeader<S, ST>;
5293    pub type ViewMut<S> = super::AttPrepareWriteHeaderMut<S>;
5294    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttPrepareWriteHeaderWriter<S, ST>;
5295
5296    pub const MIN_SIZE_IN_BYTES: usize = 5;
5297    pub const MAX_SIZE_IN_BYTES: usize = 5;
5298    pub const SIZE_IN_BYTES: usize = 5;
5299}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
5300#[repr(u64)]
5301pub enum AttExecuteWriteFlag {
5302    CANCEL = 0,
5303    WRITE = 1,
5304
5305}
5306
5307impl core::convert::From<AttExecuteWriteFlag> for u8 { fn from(val: AttExecuteWriteFlag) -> Self { val as u8 } }
5308impl core::convert::From<AttExecuteWriteFlag> for u16 { fn from(val: AttExecuteWriteFlag) -> Self { val as u16 } }
5309impl core::convert::From<AttExecuteWriteFlag> for u32 { fn from(val: AttExecuteWriteFlag) -> Self { val as u32 } }
5310impl core::convert::From<AttExecuteWriteFlag> for u64 { fn from(val: AttExecuteWriteFlag) -> Self { val as u64 } }
5311impl core::convert::From<AttExecuteWriteFlag> for i8 { fn from(val: AttExecuteWriteFlag) -> Self { val as i8 } }
5312impl core::convert::From<AttExecuteWriteFlag> for i16 { fn from(val: AttExecuteWriteFlag) -> Self { val as i16 } }
5313impl core::convert::From<AttExecuteWriteFlag> for i32 { fn from(val: AttExecuteWriteFlag) -> Self { val as i32 } }
5314impl core::convert::From<AttExecuteWriteFlag> for i64 { fn from(val: AttExecuteWriteFlag) -> Self { val as i64 } }
5315
5316impl emboss_runtime::SafeCmp<AttExecuteWriteFlag> for AttExecuteWriteFlag {
5317    fn safe_eq(&self, other: Self) -> bool { *self == other }
5318    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
5319}
5320
5321impl emboss_runtime::SafeCmp<u64> for AttExecuteWriteFlag {
5322    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
5323    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
5324}
5325
5326impl emboss_runtime::SafeCmp<i64> for AttExecuteWriteFlag {
5327    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
5328    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
5329}
5330
5331impl emboss_runtime::SafeCmp<i32> for AttExecuteWriteFlag {
5332    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
5333    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
5334}
5335
5336impl emboss_runtime::SafeCmp<u32> for AttExecuteWriteFlag {
5337    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
5338    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
5339}
5340
5341impl emboss_runtime::SafeCmp<AttExecuteWriteFlag> for u64 {
5342    fn safe_eq(&self, other: AttExecuteWriteFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
5343    fn safe_less(&self, other: AttExecuteWriteFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
5344}
5345
5346impl emboss_runtime::SafeCmp<AttExecuteWriteFlag> for i64 {
5347    fn safe_eq(&self, other: AttExecuteWriteFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
5348    fn safe_less(&self, other: AttExecuteWriteFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
5349}
5350
5351impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for AttExecuteWriteFlag {
5352    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
5353        let v_raw: u64 = val.into();
5354        match v_raw {
5355            0 => Ok(AttExecuteWriteFlag::CANCEL),
5356            1 => Ok(AttExecuteWriteFlag::WRITE),
5357
5358            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
5359        }
5360    }
5361}
5362
5363impl AttExecuteWriteFlag {
5364
5365}
5366pub struct AttExecuteWriteReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5367    storage: S,
5368    _marker: core::marker::PhantomData<ST>,
5369}
5370
5371impl<S: emboss_runtime::Storage> AttExecuteWriteReq<S, emboss_runtime::UncheckedState> {
5372    pub fn new(storage: S) -> Self {
5373        Self {
5374            storage,
5375            _marker: core::marker::PhantomData,
5376        }
5377    }
5378}
5379
5380impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttExecuteWriteReq<S, ST> {
5381    fn clone(&self) -> Self {
5382        Self {
5383            storage: self.storage.clone(),
5384            _marker: core::marker::PhantomData,
5385        }
5386    }
5387}
5388
5389impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttExecuteWriteReq<S, ST> {
5390    /**
5391     * Constructs a view in a specific typestate.
5392     *
5393     * # Safety
5394     *
5395     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5396     */
5397    pub unsafe fn new_in_state(storage: S) -> Self {
5398        Self {
5399            storage,
5400            _marker: core::marker::PhantomData,
5401        }
5402    }
5403    pub fn into_storage(self) -> S {
5404        self.storage
5405    }
5406    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
5407        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5408            let offset = (0) as usize;
5409            let len = (1) as usize;
5410            core::result::Result::Ok((offset, len))
5411        })().unwrap_or((usize::MAX, 0));
5412        let storage = self.storage.slice(offset, len);
5413        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
5414    }
5415    pub fn flags(&self) -> emboss_runtime::EnumView<AttExecuteWriteFlag, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
5416        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5417            let offset = (1) as usize;
5418            let len = (1) as usize;
5419            core::result::Result::Ok((offset, len))
5420        })().unwrap_or((usize::MAX, 0));
5421        let storage = self.storage.slice(offset, len);
5422        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
5423    }
5424
5425}
5426
5427pub struct AttExecuteWriteReqMut<S: emboss_runtime::MutStorage> {
5428    storage: S,
5429}
5430
5431impl<S: emboss_runtime::MutStorage> AttExecuteWriteReqMut<S> {
5432    pub fn new(storage: S) -> Self {
5433        Self {
5434            storage,
5435        }
5436    }
5437    pub fn into_writer(self) -> AttExecuteWriteReqWriter<S, emboss_runtime::UncheckedState> {
5438        AttExecuteWriteReqWriter::new(self.storage)
5439    }
5440    /** Borrows the mutable view as an immutable view in UncheckedState. */
5441    pub fn as_view(&self) -> AttExecuteWriteReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
5442        unsafe { AttExecuteWriteReq::new_in_state(self.storage.slice(0, self.storage.len())) }
5443    }
5444    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
5445        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5446            let offset = (0) as usize;
5447            let len = (1) as usize;
5448            core::result::Result::Ok((offset, len))
5449        })().unwrap_or((usize::MAX, 0));
5450        let storage = self.storage.slice_mut(offset, len);
5451        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
5452    }
5453    pub fn flags(&mut self) -> emboss_runtime::EnumViewMut<AttExecuteWriteFlag, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
5454        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5455            let offset = (1) as usize;
5456            let len = (1) as usize;
5457            core::result::Result::Ok((offset, len))
5458        })().unwrap_or((usize::MAX, 0));
5459        let storage = self.storage.slice_mut(offset, len);
5460        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
5461    }
5462
5463}
5464
5465impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttExecuteWriteReqMut<S> {
5466    type Writer = AttExecuteWriteReqWriter<S, emboss_runtime::UncheckedState>;
5467    fn into_writer(self) -> Self::Writer {
5468        AttExecuteWriteReqWriter::new(self.storage)
5469    }
5470}
5471
5472pub struct AttExecuteWriteReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5473    storage: S,
5474    _marker: core::marker::PhantomData<ST>,
5475}
5476
5477impl<S: emboss_runtime::MutStorage> AttExecuteWriteReqWriter<S, emboss_runtime::UncheckedState> {
5478    pub fn new(storage: S) -> Self {
5479        Self {
5480            storage,
5481            _marker: core::marker::PhantomData,
5482        }
5483    }
5484}
5485
5486impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttExecuteWriteReqWriter<S, ST> {
5487    /**
5488     * Constructs a writer in a specific typestate.
5489     *
5490     * # Safety
5491     *
5492     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5493     */
5494    pub unsafe fn new_in_state(storage: S) -> Self {
5495        Self {
5496            storage,
5497            _marker: core::marker::PhantomData,
5498        }
5499    }
5500    pub fn into_storage(self) -> S {
5501        self.storage
5502    }
5503    /** Converts the writer into an immutable view in the same typestate. */
5504    pub fn into_view(self) -> AttExecuteWriteReq<S, ST> {
5505        unsafe { AttExecuteWriteReq::new_in_state(self.storage) }
5506    }
5507    /** Borrows the writer as an immutable view in the same typestate. */
5508    pub fn as_view(&self) -> AttExecuteWriteReq<S::Sliced<'_>, ST> {
5509        unsafe { AttExecuteWriteReq::new_in_state(self.storage.slice(0, self.storage.len())) }
5510    }
5511    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttExecuteWriteReqWriter<S, ST::OnValidMutation> {
5512        let view = self.into_view();
5513        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5514            let offset = (0) as usize;
5515            let len = (1) as usize;
5516            core::result::Result::Ok((offset, len))
5517        })().expect("valid layout in complete state");
5518        let mut storage = view.into_storage();
5519        {
5520            let slice = storage.slice_mut(offset, len);
5521            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
5522            field_view.try_write(val).expect("valid write in complete state");
5523        }
5524        unsafe { AttExecuteWriteReqWriter::new_in_state(storage) }
5525    }
5526    pub fn write_flags(self, val: AttExecuteWriteFlag) -> AttExecuteWriteReqWriter<S, ST::OnValidMutation> {
5527        let view = self.into_view();
5528        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5529            let offset = (1) as usize;
5530            let len = (1) as usize;
5531            core::result::Result::Ok((offset, len))
5532        })().expect("valid layout in complete state");
5533        let mut storage = view.into_storage();
5534        {
5535            let slice = storage.slice_mut(offset, len);
5536            let mut field_view = emboss_runtime::EnumViewMut::<AttExecuteWriteFlag, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
5537            field_view.try_write(val).expect("valid write in complete state");
5538        }
5539        unsafe { AttExecuteWriteReqWriter::new_in_state(storage) }
5540    }
5541
5542}
5543
5544impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttExecuteWriteReq<S, ST> {
5545    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5546        let view = self;
5547        core::result::Result::Ok((2) as usize)
5548    }
5549}
5550
5551impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttExecuteWriteReqMut<S> {
5552    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5553        let view = self.as_view();
5554        <AttExecuteWriteReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
5555    }
5556}
5557
5558impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttExecuteWriteReqWriter<S, ST> {
5559    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5560        let view = self.as_view();
5561        <AttExecuteWriteReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
5562    }
5563}
5564
5565impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttExecuteWriteReq<S, emboss_runtime::UncheckedState> {
5566    type Completed = AttExecuteWriteReq<S, emboss_runtime::CompleteState>;
5567    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5568        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5569        if self.storage.len() < required_size {
5570            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5571        }
5572        core::result::Result::Ok(unsafe { AttExecuteWriteReq::new_in_state(self.storage) })
5573    }
5574}
5575
5576impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttExecuteWriteReqWriter<S, emboss_runtime::UncheckedState> {
5577    type Completed = AttExecuteWriteReqWriter<S, emboss_runtime::CompleteState>;
5578    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5579        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5580        if self.storage.len() < required_size {
5581            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5582        }
5583        core::result::Result::Ok(unsafe { AttExecuteWriteReqWriter::new_in_state(self.storage) })
5584    }
5585}
5586
5587impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExecuteWriteReq<S, emboss_runtime::UncheckedState> {
5588    type Ok = AttExecuteWriteReq<S, emboss_runtime::OkState>;
5589    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5590        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5591        core::result::Result::Ok(unsafe { AttExecuteWriteReq::new_in_state(completed.into_storage()) })
5592    }
5593}
5594
5595impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExecuteWriteReq<S, emboss_runtime::CompleteState> {
5596    type Ok = AttExecuteWriteReq<S, emboss_runtime::OkState>;
5597    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5598        core::result::Result::Ok(unsafe { AttExecuteWriteReq::new_in_state(self.into_storage()) })
5599    }
5600}
5601
5602impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttExecuteWriteReq<S, emboss_runtime::OkState> {
5603    type Ok = AttExecuteWriteReq<S, emboss_runtime::OkState>;
5604    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5605        core::result::Result::Ok(self)
5606    }
5607}
5608
5609impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExecuteWriteReqWriter<S, emboss_runtime::UncheckedState> {
5610    type Ok = AttExecuteWriteReqWriter<S, emboss_runtime::OkState>;
5611    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5612        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5613        core::result::Result::Ok(unsafe { AttExecuteWriteReqWriter::new_in_state(completed.into_storage()) })
5614    }
5615}
5616
5617impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExecuteWriteReqWriter<S, emboss_runtime::CompleteState> {
5618    type Ok = AttExecuteWriteReqWriter<S, emboss_runtime::OkState>;
5619    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5620        core::result::Result::Ok(unsafe { AttExecuteWriteReqWriter::new_in_state(self.into_storage()) })
5621    }
5622}
5623
5624impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttExecuteWriteReqWriter<S, emboss_runtime::OkState> {
5625    type Ok = AttExecuteWriteReqWriter<S, emboss_runtime::OkState>;
5626    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5627        core::result::Result::Ok(self)
5628    }
5629}
5630
5631pub mod att_execute_write_req {
5632    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttExecuteWriteReq<S, ST>;
5633    pub type ViewMut<S> = super::AttExecuteWriteReqMut<S>;
5634    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttExecuteWriteReqWriter<S, ST>;
5635
5636    pub const MIN_SIZE_IN_BYTES: usize = 2;
5637    pub const MAX_SIZE_IN_BYTES: usize = 2;
5638    pub const SIZE_IN_BYTES: usize = 2;
5639}pub struct AttHandleValueNtf<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5640    storage: S,
5641    _marker: core::marker::PhantomData<ST>,
5642}
5643
5644impl<S: emboss_runtime::Storage> AttHandleValueNtf<S, emboss_runtime::UncheckedState> {
5645    pub fn new(storage: S) -> Self {
5646        Self {
5647            storage,
5648            _marker: core::marker::PhantomData,
5649        }
5650    }
5651}
5652
5653impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttHandleValueNtf<S, ST> {
5654    fn clone(&self) -> Self {
5655        Self {
5656            storage: self.storage.clone(),
5657            _marker: core::marker::PhantomData,
5658        }
5659    }
5660}
5661
5662impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttHandleValueNtf<S, ST> {
5663    /**
5664     * Constructs a view in a specific typestate.
5665     *
5666     * # Safety
5667     *
5668     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5669     */
5670    pub unsafe fn new_in_state(storage: S) -> Self {
5671        Self {
5672            storage,
5673            _marker: core::marker::PhantomData,
5674        }
5675    }
5676    pub fn into_storage(self) -> S {
5677        self.storage
5678    }
5679    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
5680        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5681            let offset = (0) as usize;
5682            let len = (1) as usize;
5683            core::result::Result::Ok((offset, len))
5684        })().unwrap_or((usize::MAX, 0));
5685        let storage = self.storage.slice(offset, len);
5686        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
5687    }
5688    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
5689        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5690            let offset = (1) as usize;
5691            let len = (2) as usize;
5692            core::result::Result::Ok((offset, len))
5693        })().unwrap_or((usize::MAX, 0));
5694        let storage = self.storage.slice(offset, len);
5695        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
5696    }
5697
5698}
5699
5700pub struct AttHandleValueNtfMut<S: emboss_runtime::MutStorage> {
5701    storage: S,
5702}
5703
5704impl<S: emboss_runtime::MutStorage> AttHandleValueNtfMut<S> {
5705    pub fn new(storage: S) -> Self {
5706        Self {
5707            storage,
5708        }
5709    }
5710    pub fn into_writer(self) -> AttHandleValueNtfWriter<S, emboss_runtime::UncheckedState> {
5711        AttHandleValueNtfWriter::new(self.storage)
5712    }
5713    /** Borrows the mutable view as an immutable view in UncheckedState. */
5714    pub fn as_view(&self) -> AttHandleValueNtf<S::Sliced<'_>, emboss_runtime::UncheckedState> {
5715        unsafe { AttHandleValueNtf::new_in_state(self.storage.slice(0, self.storage.len())) }
5716    }
5717    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
5718        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5719            let offset = (0) as usize;
5720            let len = (1) as usize;
5721            core::result::Result::Ok((offset, len))
5722        })().unwrap_or((usize::MAX, 0));
5723        let storage = self.storage.slice_mut(offset, len);
5724        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
5725    }
5726    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
5727        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5728            let offset = (1) as usize;
5729            let len = (2) as usize;
5730            core::result::Result::Ok((offset, len))
5731        })().unwrap_or((usize::MAX, 0));
5732        let storage = self.storage.slice_mut(offset, len);
5733        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
5734    }
5735
5736}
5737
5738impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttHandleValueNtfMut<S> {
5739    type Writer = AttHandleValueNtfWriter<S, emboss_runtime::UncheckedState>;
5740    fn into_writer(self) -> Self::Writer {
5741        AttHandleValueNtfWriter::new(self.storage)
5742    }
5743}
5744
5745pub struct AttHandleValueNtfWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5746    storage: S,
5747    _marker: core::marker::PhantomData<ST>,
5748}
5749
5750impl<S: emboss_runtime::MutStorage> AttHandleValueNtfWriter<S, emboss_runtime::UncheckedState> {
5751    pub fn new(storage: S) -> Self {
5752        Self {
5753            storage,
5754            _marker: core::marker::PhantomData,
5755        }
5756    }
5757}
5758
5759impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttHandleValueNtfWriter<S, ST> {
5760    /**
5761     * Constructs a writer in a specific typestate.
5762     *
5763     * # Safety
5764     *
5765     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5766     */
5767    pub unsafe fn new_in_state(storage: S) -> Self {
5768        Self {
5769            storage,
5770            _marker: core::marker::PhantomData,
5771        }
5772    }
5773    pub fn into_storage(self) -> S {
5774        self.storage
5775    }
5776    /** Converts the writer into an immutable view in the same typestate. */
5777    pub fn into_view(self) -> AttHandleValueNtf<S, ST> {
5778        unsafe { AttHandleValueNtf::new_in_state(self.storage) }
5779    }
5780    /** Borrows the writer as an immutable view in the same typestate. */
5781    pub fn as_view(&self) -> AttHandleValueNtf<S::Sliced<'_>, ST> {
5782        unsafe { AttHandleValueNtf::new_in_state(self.storage.slice(0, self.storage.len())) }
5783    }
5784    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttHandleValueNtfWriter<S, ST::OnValidMutation> {
5785        let view = self.into_view();
5786        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5787            let offset = (0) as usize;
5788            let len = (1) as usize;
5789            core::result::Result::Ok((offset, len))
5790        })().expect("valid layout in complete state");
5791        let mut storage = view.into_storage();
5792        {
5793            let slice = storage.slice_mut(offset, len);
5794            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
5795            field_view.try_write(val).expect("valid write in complete state");
5796        }
5797        unsafe { AttHandleValueNtfWriter::new_in_state(storage) }
5798    }
5799    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttHandleValueNtfWriter<S, ST::OnValidMutation> {
5800        let view = self.into_view();
5801        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5802            let offset = (1) as usize;
5803            let len = (2) as usize;
5804            core::result::Result::Ok((offset, len))
5805        })().expect("valid layout in complete state");
5806        let mut storage = view.into_storage();
5807        {
5808            let slice = storage.slice_mut(offset, len);
5809            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
5810            field_view.try_write(val).expect("valid write in complete state");
5811        }
5812        unsafe { AttHandleValueNtfWriter::new_in_state(storage) }
5813    }
5814
5815}
5816
5817impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueNtf<S, ST> {
5818    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5819        let view = self;
5820        core::result::Result::Ok((0) as usize)
5821    }
5822}
5823
5824impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttHandleValueNtfMut<S> {
5825    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5826        let view = self.as_view();
5827        <AttHandleValueNtf<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
5828    }
5829}
5830
5831impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueNtfWriter<S, ST> {
5832    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
5833        let view = self.as_view();
5834        <AttHandleValueNtf<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
5835    }
5836}
5837
5838impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttHandleValueNtf<S, emboss_runtime::UncheckedState> {
5839    type Completed = AttHandleValueNtf<S, emboss_runtime::CompleteState>;
5840    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5841        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5842        if self.storage.len() < required_size {
5843            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5844        }
5845        core::result::Result::Ok(unsafe { AttHandleValueNtf::new_in_state(self.storage) })
5846    }
5847}
5848
5849impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttHandleValueNtfWriter<S, emboss_runtime::UncheckedState> {
5850    type Completed = AttHandleValueNtfWriter<S, emboss_runtime::CompleteState>;
5851    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
5852        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
5853        if self.storage.len() < required_size {
5854            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
5855        }
5856        core::result::Result::Ok(unsafe { AttHandleValueNtfWriter::new_in_state(self.storage) })
5857    }
5858}
5859
5860impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtf<S, emboss_runtime::UncheckedState> {
5861    type Ok = AttHandleValueNtf<S, emboss_runtime::OkState>;
5862    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5863        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5864        core::result::Result::Ok(unsafe { AttHandleValueNtf::new_in_state(completed.into_storage()) })
5865    }
5866}
5867
5868impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtf<S, emboss_runtime::CompleteState> {
5869    type Ok = AttHandleValueNtf<S, emboss_runtime::OkState>;
5870    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5871        core::result::Result::Ok(unsafe { AttHandleValueNtf::new_in_state(self.into_storage()) })
5872    }
5873}
5874
5875impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtf<S, emboss_runtime::OkState> {
5876    type Ok = AttHandleValueNtf<S, emboss_runtime::OkState>;
5877    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5878        core::result::Result::Ok(self)
5879    }
5880}
5881
5882impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfWriter<S, emboss_runtime::UncheckedState> {
5883    type Ok = AttHandleValueNtfWriter<S, emboss_runtime::OkState>;
5884    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5885        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
5886        core::result::Result::Ok(unsafe { AttHandleValueNtfWriter::new_in_state(completed.into_storage()) })
5887    }
5888}
5889
5890impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfWriter<S, emboss_runtime::CompleteState> {
5891    type Ok = AttHandleValueNtfWriter<S, emboss_runtime::OkState>;
5892    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5893        core::result::Result::Ok(unsafe { AttHandleValueNtfWriter::new_in_state(self.into_storage()) })
5894    }
5895}
5896
5897impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfWriter<S, emboss_runtime::OkState> {
5898    type Ok = AttHandleValueNtfWriter<S, emboss_runtime::OkState>;
5899    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
5900        core::result::Result::Ok(self)
5901    }
5902}
5903
5904pub mod att_handle_value_ntf {
5905    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueNtf<S, ST>;
5906    pub type ViewMut<S> = super::AttHandleValueNtfMut<S>;
5907    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueNtfWriter<S, ST>;
5908
5909    pub const MIN_SIZE_IN_BYTES: usize = 3;
5910    pub const MAX_SIZE_IN_BYTES: usize = 65538;
5911}pub struct AttHandleValueNtfHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
5912    storage: S,
5913    _marker: core::marker::PhantomData<ST>,
5914}
5915
5916impl<S: emboss_runtime::Storage> AttHandleValueNtfHeader<S, emboss_runtime::UncheckedState> {
5917    pub fn new(storage: S) -> Self {
5918        Self {
5919            storage,
5920            _marker: core::marker::PhantomData,
5921        }
5922    }
5923}
5924
5925impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttHandleValueNtfHeader<S, ST> {
5926    fn clone(&self) -> Self {
5927        Self {
5928            storage: self.storage.clone(),
5929            _marker: core::marker::PhantomData,
5930        }
5931    }
5932}
5933
5934impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttHandleValueNtfHeader<S, ST> {
5935    /**
5936     * Constructs a view in a specific typestate.
5937     *
5938     * # Safety
5939     *
5940     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
5941     */
5942    pub unsafe fn new_in_state(storage: S) -> Self {
5943        Self {
5944            storage,
5945            _marker: core::marker::PhantomData,
5946        }
5947    }
5948    pub fn into_storage(self) -> S {
5949        self.storage
5950    }
5951    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
5952        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5953            let offset = (0) as usize;
5954            let len = (1) as usize;
5955            core::result::Result::Ok((offset, len))
5956        })().unwrap_or((usize::MAX, 0));
5957        let storage = self.storage.slice(offset, len);
5958        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
5959    }
5960    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
5961        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5962            let offset = (1) as usize;
5963            let len = (2) as usize;
5964            core::result::Result::Ok((offset, len))
5965        })().unwrap_or((usize::MAX, 0));
5966        let storage = self.storage.slice(offset, len);
5967        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
5968    }
5969
5970}
5971
5972pub struct AttHandleValueNtfHeaderMut<S: emboss_runtime::MutStorage> {
5973    storage: S,
5974}
5975
5976impl<S: emboss_runtime::MutStorage> AttHandleValueNtfHeaderMut<S> {
5977    pub fn new(storage: S) -> Self {
5978        Self {
5979            storage,
5980        }
5981    }
5982    pub fn into_writer(self) -> AttHandleValueNtfHeaderWriter<S, emboss_runtime::UncheckedState> {
5983        AttHandleValueNtfHeaderWriter::new(self.storage)
5984    }
5985    /** Borrows the mutable view as an immutable view in UncheckedState. */
5986    pub fn as_view(&self) -> AttHandleValueNtfHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
5987        unsafe { AttHandleValueNtfHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
5988    }
5989    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
5990        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
5991            let offset = (0) as usize;
5992            let len = (1) as usize;
5993            core::result::Result::Ok((offset, len))
5994        })().unwrap_or((usize::MAX, 0));
5995        let storage = self.storage.slice_mut(offset, len);
5996        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
5997    }
5998    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
5999        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6000            let offset = (1) as usize;
6001            let len = (2) as usize;
6002            core::result::Result::Ok((offset, len))
6003        })().unwrap_or((usize::MAX, 0));
6004        let storage = self.storage.slice_mut(offset, len);
6005        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
6006    }
6007
6008}
6009
6010impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttHandleValueNtfHeaderMut<S> {
6011    type Writer = AttHandleValueNtfHeaderWriter<S, emboss_runtime::UncheckedState>;
6012    fn into_writer(self) -> Self::Writer {
6013        AttHandleValueNtfHeaderWriter::new(self.storage)
6014    }
6015}
6016
6017pub struct AttHandleValueNtfHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
6018    storage: S,
6019    _marker: core::marker::PhantomData<ST>,
6020}
6021
6022impl<S: emboss_runtime::MutStorage> AttHandleValueNtfHeaderWriter<S, emboss_runtime::UncheckedState> {
6023    pub fn new(storage: S) -> Self {
6024        Self {
6025            storage,
6026            _marker: core::marker::PhantomData,
6027        }
6028    }
6029}
6030
6031impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttHandleValueNtfHeaderWriter<S, ST> {
6032    /**
6033     * Constructs a writer in a specific typestate.
6034     *
6035     * # Safety
6036     *
6037     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
6038     */
6039    pub unsafe fn new_in_state(storage: S) -> Self {
6040        Self {
6041            storage,
6042            _marker: core::marker::PhantomData,
6043        }
6044    }
6045    pub fn into_storage(self) -> S {
6046        self.storage
6047    }
6048    /** Converts the writer into an immutable view in the same typestate. */
6049    pub fn into_view(self) -> AttHandleValueNtfHeader<S, ST> {
6050        unsafe { AttHandleValueNtfHeader::new_in_state(self.storage) }
6051    }
6052    /** Borrows the writer as an immutable view in the same typestate. */
6053    pub fn as_view(&self) -> AttHandleValueNtfHeader<S::Sliced<'_>, ST> {
6054        unsafe { AttHandleValueNtfHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
6055    }
6056    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttHandleValueNtfHeaderWriter<S, ST::OnValidMutation> {
6057        let view = self.into_view();
6058        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6059            let offset = (0) as usize;
6060            let len = (1) as usize;
6061            core::result::Result::Ok((offset, len))
6062        })().expect("valid layout in complete state");
6063        let mut storage = view.into_storage();
6064        {
6065            let slice = storage.slice_mut(offset, len);
6066            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
6067            field_view.try_write(val).expect("valid write in complete state");
6068        }
6069        unsafe { AttHandleValueNtfHeaderWriter::new_in_state(storage) }
6070    }
6071    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttHandleValueNtfHeaderWriter<S, ST::OnValidMutation> {
6072        let view = self.into_view();
6073        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6074            let offset = (1) as usize;
6075            let len = (2) as usize;
6076            core::result::Result::Ok((offset, len))
6077        })().expect("valid layout in complete state");
6078        let mut storage = view.into_storage();
6079        {
6080            let slice = storage.slice_mut(offset, len);
6081            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
6082            field_view.try_write(val).expect("valid write in complete state");
6083        }
6084        unsafe { AttHandleValueNtfHeaderWriter::new_in_state(storage) }
6085    }
6086
6087}
6088
6089impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueNtfHeader<S, ST> {
6090    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6091        let view = self;
6092        core::result::Result::Ok((3) as usize)
6093    }
6094}
6095
6096impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttHandleValueNtfHeaderMut<S> {
6097    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6098        let view = self.as_view();
6099        <AttHandleValueNtfHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
6100    }
6101}
6102
6103impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueNtfHeaderWriter<S, ST> {
6104    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6105        let view = self.as_view();
6106        <AttHandleValueNtfHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
6107    }
6108}
6109
6110impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttHandleValueNtfHeader<S, emboss_runtime::UncheckedState> {
6111    type Completed = AttHandleValueNtfHeader<S, emboss_runtime::CompleteState>;
6112    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
6113        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
6114        if self.storage.len() < required_size {
6115            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
6116        }
6117        core::result::Result::Ok(unsafe { AttHandleValueNtfHeader::new_in_state(self.storage) })
6118    }
6119}
6120
6121impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttHandleValueNtfHeaderWriter<S, emboss_runtime::UncheckedState> {
6122    type Completed = AttHandleValueNtfHeaderWriter<S, emboss_runtime::CompleteState>;
6123    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
6124        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
6125        if self.storage.len() < required_size {
6126            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
6127        }
6128        core::result::Result::Ok(unsafe { AttHandleValueNtfHeaderWriter::new_in_state(self.storage) })
6129    }
6130}
6131
6132impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtfHeader<S, emboss_runtime::UncheckedState> {
6133    type Ok = AttHandleValueNtfHeader<S, emboss_runtime::OkState>;
6134    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6135        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
6136        core::result::Result::Ok(unsafe { AttHandleValueNtfHeader::new_in_state(completed.into_storage()) })
6137    }
6138}
6139
6140impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtfHeader<S, emboss_runtime::CompleteState> {
6141    type Ok = AttHandleValueNtfHeader<S, emboss_runtime::OkState>;
6142    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6143        core::result::Result::Ok(unsafe { AttHandleValueNtfHeader::new_in_state(self.into_storage()) })
6144    }
6145}
6146
6147impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueNtfHeader<S, emboss_runtime::OkState> {
6148    type Ok = AttHandleValueNtfHeader<S, emboss_runtime::OkState>;
6149    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6150        core::result::Result::Ok(self)
6151    }
6152}
6153
6154impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfHeaderWriter<S, emboss_runtime::UncheckedState> {
6155    type Ok = AttHandleValueNtfHeaderWriter<S, emboss_runtime::OkState>;
6156    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6157        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
6158        core::result::Result::Ok(unsafe { AttHandleValueNtfHeaderWriter::new_in_state(completed.into_storage()) })
6159    }
6160}
6161
6162impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfHeaderWriter<S, emboss_runtime::CompleteState> {
6163    type Ok = AttHandleValueNtfHeaderWriter<S, emboss_runtime::OkState>;
6164    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6165        core::result::Result::Ok(unsafe { AttHandleValueNtfHeaderWriter::new_in_state(self.into_storage()) })
6166    }
6167}
6168
6169impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueNtfHeaderWriter<S, emboss_runtime::OkState> {
6170    type Ok = AttHandleValueNtfHeaderWriter<S, emboss_runtime::OkState>;
6171    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6172        core::result::Result::Ok(self)
6173    }
6174}
6175
6176pub mod att_handle_value_ntf_header {
6177    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueNtfHeader<S, ST>;
6178    pub type ViewMut<S> = super::AttHandleValueNtfHeaderMut<S>;
6179    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueNtfHeaderWriter<S, ST>;
6180
6181    pub const MIN_SIZE_IN_BYTES: usize = 3;
6182    pub const MAX_SIZE_IN_BYTES: usize = 3;
6183    pub const SIZE_IN_BYTES: usize = 3;
6184}pub struct AttHandleValueIndHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
6185    storage: S,
6186    _marker: core::marker::PhantomData<ST>,
6187}
6188
6189impl<S: emboss_runtime::Storage> AttHandleValueIndHeader<S, emboss_runtime::UncheckedState> {
6190    pub fn new(storage: S) -> Self {
6191        Self {
6192            storage,
6193            _marker: core::marker::PhantomData,
6194        }
6195    }
6196}
6197
6198impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AttHandleValueIndHeader<S, ST> {
6199    fn clone(&self) -> Self {
6200        Self {
6201            storage: self.storage.clone(),
6202            _marker: core::marker::PhantomData,
6203        }
6204    }
6205}
6206
6207impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AttHandleValueIndHeader<S, ST> {
6208    /**
6209     * Constructs a view in a specific typestate.
6210     *
6211     * # Safety
6212     *
6213     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
6214     */
6215    pub unsafe fn new_in_state(storage: S) -> Self {
6216        Self {
6217            storage,
6218            _marker: core::marker::PhantomData,
6219        }
6220    }
6221    pub fn into_storage(self) -> S {
6222        self.storage
6223    }
6224    pub fn attribute_opcode(&self) -> emboss_runtime::EnumView<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
6225        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6226            let offset = (0) as usize;
6227            let len = (1) as usize;
6228            core::result::Result::Ok((offset, len))
6229        })().unwrap_or((usize::MAX, 0));
6230        let storage = self.storage.slice(offset, len);
6231        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
6232    }
6233    pub fn attribute_handle(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
6234        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6235            let offset = (1) as usize;
6236            let len = (2) as usize;
6237            core::result::Result::Ok((offset, len))
6238        })().unwrap_or((usize::MAX, 0));
6239        let storage = self.storage.slice(offset, len);
6240        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
6241    }
6242
6243}
6244
6245pub struct AttHandleValueIndHeaderMut<S: emboss_runtime::MutStorage> {
6246    storage: S,
6247}
6248
6249impl<S: emboss_runtime::MutStorage> AttHandleValueIndHeaderMut<S> {
6250    pub fn new(storage: S) -> Self {
6251        Self {
6252            storage,
6253        }
6254    }
6255    pub fn into_writer(self) -> AttHandleValueIndHeaderWriter<S, emboss_runtime::UncheckedState> {
6256        AttHandleValueIndHeaderWriter::new(self.storage)
6257    }
6258    /** Borrows the mutable view as an immutable view in UncheckedState. */
6259    pub fn as_view(&self) -> AttHandleValueIndHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
6260        unsafe { AttHandleValueIndHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
6261    }
6262    pub fn attribute_opcode(&mut self) -> emboss_runtime::EnumViewMut<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
6263        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6264            let offset = (0) as usize;
6265            let len = (1) as usize;
6266            core::result::Result::Ok((offset, len))
6267        })().unwrap_or((usize::MAX, 0));
6268        let storage = self.storage.slice_mut(offset, len);
6269        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
6270    }
6271    pub fn attribute_handle(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
6272        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6273            let offset = (1) as usize;
6274            let len = (2) as usize;
6275            core::result::Result::Ok((offset, len))
6276        })().unwrap_or((usize::MAX, 0));
6277        let storage = self.storage.slice_mut(offset, len);
6278        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
6279    }
6280
6281}
6282
6283impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AttHandleValueIndHeaderMut<S> {
6284    type Writer = AttHandleValueIndHeaderWriter<S, emboss_runtime::UncheckedState>;
6285    fn into_writer(self) -> Self::Writer {
6286        AttHandleValueIndHeaderWriter::new(self.storage)
6287    }
6288}
6289
6290pub struct AttHandleValueIndHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
6291    storage: S,
6292    _marker: core::marker::PhantomData<ST>,
6293}
6294
6295impl<S: emboss_runtime::MutStorage> AttHandleValueIndHeaderWriter<S, emboss_runtime::UncheckedState> {
6296    pub fn new(storage: S) -> Self {
6297        Self {
6298            storage,
6299            _marker: core::marker::PhantomData,
6300        }
6301    }
6302}
6303
6304impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AttHandleValueIndHeaderWriter<S, ST> {
6305    /**
6306     * Constructs a writer in a specific typestate.
6307     *
6308     * # Safety
6309     *
6310     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
6311     */
6312    pub unsafe fn new_in_state(storage: S) -> Self {
6313        Self {
6314            storage,
6315            _marker: core::marker::PhantomData,
6316        }
6317    }
6318    pub fn into_storage(self) -> S {
6319        self.storage
6320    }
6321    /** Converts the writer into an immutable view in the same typestate. */
6322    pub fn into_view(self) -> AttHandleValueIndHeader<S, ST> {
6323        unsafe { AttHandleValueIndHeader::new_in_state(self.storage) }
6324    }
6325    /** Borrows the writer as an immutable view in the same typestate. */
6326    pub fn as_view(&self) -> AttHandleValueIndHeader<S::Sliced<'_>, ST> {
6327        unsafe { AttHandleValueIndHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
6328    }
6329    pub fn write_attribute_opcode(self, val: AttOpcode) -> AttHandleValueIndHeaderWriter<S, ST::OnValidMutation> {
6330        let view = self.into_view();
6331        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6332            let offset = (0) as usize;
6333            let len = (1) as usize;
6334            core::result::Result::Ok((offset, len))
6335        })().expect("valid layout in complete state");
6336        let mut storage = view.into_storage();
6337        {
6338            let slice = storage.slice_mut(offset, len);
6339            let mut field_view = emboss_runtime::EnumViewMut::<AttOpcode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
6340            field_view.try_write(val).expect("valid write in complete state");
6341        }
6342        unsafe { AttHandleValueIndHeaderWriter::new_in_state(storage) }
6343    }
6344    pub fn write_attribute_handle(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AttHandleValueIndHeaderWriter<S, ST::OnValidMutation> {
6345        let view = self.into_view();
6346        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
6347            let offset = (1) as usize;
6348            let len = (2) as usize;
6349            core::result::Result::Ok((offset, len))
6350        })().expect("valid layout in complete state");
6351        let mut storage = view.into_storage();
6352        {
6353            let slice = storage.slice_mut(offset, len);
6354            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
6355            field_view.try_write(val).expect("valid write in complete state");
6356        }
6357        unsafe { AttHandleValueIndHeaderWriter::new_in_state(storage) }
6358    }
6359
6360}
6361
6362impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueIndHeader<S, ST> {
6363    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6364        let view = self;
6365        core::result::Result::Ok((3) as usize)
6366    }
6367}
6368
6369impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AttHandleValueIndHeaderMut<S> {
6370    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6371        let view = self.as_view();
6372        <AttHandleValueIndHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
6373    }
6374}
6375
6376impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AttHandleValueIndHeaderWriter<S, ST> {
6377    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
6378        let view = self.as_view();
6379        <AttHandleValueIndHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
6380    }
6381}
6382
6383impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AttHandleValueIndHeader<S, emboss_runtime::UncheckedState> {
6384    type Completed = AttHandleValueIndHeader<S, emboss_runtime::CompleteState>;
6385    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
6386        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
6387        if self.storage.len() < required_size {
6388            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
6389        }
6390        core::result::Result::Ok(unsafe { AttHandleValueIndHeader::new_in_state(self.storage) })
6391    }
6392}
6393
6394impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AttHandleValueIndHeaderWriter<S, emboss_runtime::UncheckedState> {
6395    type Completed = AttHandleValueIndHeaderWriter<S, emboss_runtime::CompleteState>;
6396    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
6397        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
6398        if self.storage.len() < required_size {
6399            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
6400        }
6401        core::result::Result::Ok(unsafe { AttHandleValueIndHeaderWriter::new_in_state(self.storage) })
6402    }
6403}
6404
6405impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueIndHeader<S, emboss_runtime::UncheckedState> {
6406    type Ok = AttHandleValueIndHeader<S, emboss_runtime::OkState>;
6407    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6408        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
6409        core::result::Result::Ok(unsafe { AttHandleValueIndHeader::new_in_state(completed.into_storage()) })
6410    }
6411}
6412
6413impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueIndHeader<S, emboss_runtime::CompleteState> {
6414    type Ok = AttHandleValueIndHeader<S, emboss_runtime::OkState>;
6415    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6416        core::result::Result::Ok(unsafe { AttHandleValueIndHeader::new_in_state(self.into_storage()) })
6417    }
6418}
6419
6420impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AttHandleValueIndHeader<S, emboss_runtime::OkState> {
6421    type Ok = AttHandleValueIndHeader<S, emboss_runtime::OkState>;
6422    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6423        core::result::Result::Ok(self)
6424    }
6425}
6426
6427impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueIndHeaderWriter<S, emboss_runtime::UncheckedState> {
6428    type Ok = AttHandleValueIndHeaderWriter<S, emboss_runtime::OkState>;
6429    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6430        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
6431        core::result::Result::Ok(unsafe { AttHandleValueIndHeaderWriter::new_in_state(completed.into_storage()) })
6432    }
6433}
6434
6435impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueIndHeaderWriter<S, emboss_runtime::CompleteState> {
6436    type Ok = AttHandleValueIndHeaderWriter<S, emboss_runtime::OkState>;
6437    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6438        core::result::Result::Ok(unsafe { AttHandleValueIndHeaderWriter::new_in_state(self.into_storage()) })
6439    }
6440}
6441
6442impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AttHandleValueIndHeaderWriter<S, emboss_runtime::OkState> {
6443    type Ok = AttHandleValueIndHeaderWriter<S, emboss_runtime::OkState>;
6444    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
6445        core::result::Result::Ok(self)
6446    }
6447}
6448
6449pub mod att_handle_value_ind_header {
6450    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueIndHeader<S, ST>;
6451    pub type ViewMut<S> = super::AttHandleValueIndHeaderMut<S>;
6452    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AttHandleValueIndHeaderWriter<S, ST>;
6453
6454    pub const MIN_SIZE_IN_BYTES: usize = 3;
6455    pub const MAX_SIZE_IN_BYTES: usize = 3;
6456    pub const SIZE_IN_BYTES: usize = 3;
6457}
pw_bluetooth_att_emb/att.rs

pw_bluetooth_att_emb/
att.rs
