havok_classes/generated/
hkbStateMachineTransitionInfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbStateMachineTransitionInfo`
5/// - version: `1`
6/// - signature: `0xcdec8025`
7/// - size: ` 60`(x86)/` 72`(x86_64)
8/// -  vtable: `false`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkbStateMachineTransitionInfo {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `triggerInterval`(ctype: `struct hkbStateMachineTimeInterval`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: ` 16`(x86)/` 16`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "triggerInterval"))]
31    #[cfg_attr(feature = "serde", serde(rename = "triggerInterval"))]
32    pub m_triggerInterval: hkbStateMachineTimeInterval,
33    /// # C++ Info
34    /// - name: `initiateInterval`(ctype: `struct hkbStateMachineTimeInterval`)
35    /// - offset: ` 16`(x86)/` 16`(x86_64)
36    /// - type_size: ` 16`(x86)/` 16`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "initiateInterval"))]
38    #[cfg_attr(feature = "serde", serde(rename = "initiateInterval"))]
39    pub m_initiateInterval: hkbStateMachineTimeInterval,
40    /// # C++ Info
41    /// - name: `transition`(ctype: `struct hkbTransitionEffect*`)
42    /// - offset: ` 32`(x86)/` 32`(x86_64)
43    /// - type_size: `  4`(x86)/`  8`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "transition"))]
45    #[cfg_attr(feature = "serde", serde(rename = "transition"))]
46    pub m_transition: Pointer,
47    /// # C++ Info
48    /// - name: `condition`(ctype: `struct hkbCondition*`)
49    /// - offset: ` 36`(x86)/` 40`(x86_64)
50    /// - type_size: `  4`(x86)/`  8`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "condition"))]
52    #[cfg_attr(feature = "serde", serde(rename = "condition"))]
53    pub m_condition: Pointer,
54    /// # C++ Info
55    /// - name: `eventId`(ctype: `hkInt32`)
56    /// - offset: ` 40`(x86)/` 48`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "eventId"))]
59    #[cfg_attr(feature = "serde", serde(rename = "eventId"))]
60    pub m_eventId: i32,
61    /// # C++ Info
62    /// - name: `toStateId`(ctype: `hkInt32`)
63    /// - offset: ` 44`(x86)/` 52`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[cfg_attr(feature = "json_schema", schemars(rename = "toStateId"))]
66    #[cfg_attr(feature = "serde", serde(rename = "toStateId"))]
67    pub m_toStateId: i32,
68    /// # C++ Info
69    /// - name: `fromNestedStateId`(ctype: `hkInt32`)
70    /// - offset: ` 48`(x86)/` 56`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "fromNestedStateId"))]
73    #[cfg_attr(feature = "serde", serde(rename = "fromNestedStateId"))]
74    pub m_fromNestedStateId: i32,
75    /// # C++ Info
76    /// - name: `toNestedStateId`(ctype: `hkInt32`)
77    /// - offset: ` 52`(x86)/` 60`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(feature = "json_schema", schemars(rename = "toNestedStateId"))]
80    #[cfg_attr(feature = "serde", serde(rename = "toNestedStateId"))]
81    pub m_toNestedStateId: i32,
82    /// # C++ Info
83    /// - name: `priority`(ctype: `hkInt16`)
84    /// - offset: ` 56`(x86)/` 64`(x86_64)
85    /// - type_size: `  2`(x86)/`  2`(x86_64)
86    #[cfg_attr(feature = "json_schema", schemars(rename = "priority"))]
87    #[cfg_attr(feature = "serde", serde(rename = "priority"))]
88    pub m_priority: i16,
89    /// # C++ Info
90    /// - name: `flags`(ctype: `flags TransitionFlags`)
91    /// - offset: ` 58`(x86)/` 66`(x86_64)
92    /// - type_size: `  2`(x86)/`  2`(x86_64)
93    #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
94    #[cfg_attr(feature = "serde", serde(rename = "flags"))]
95    pub m_flags: TransitionFlags,
96}
97const _: () = {
98    use havok_serde as _serde;
99    impl _serde::HavokClass for hkbStateMachineTransitionInfo {
100        #[inline]
101        fn name(&self) -> &'static str {
102            "hkbStateMachineTransitionInfo"
103        }
104        #[inline]
105        fn signature(&self) -> _serde::__private::Signature {
106            _serde::__private::Signature::new(0xcdec8025)
107        }
108        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109        fn deps_indexes(&self) -> Vec<usize> {
110            let mut v = Vec::new();
111            v.extend(self.m_triggerInterval.deps_indexes());
112            v.extend(self.m_initiateInterval.deps_indexes());
113            v.push(self.m_transition.get());
114            v.push(self.m_condition.get());
115            v
116        }
117    }
118    impl _serde::Serialize for hkbStateMachineTransitionInfo {
119        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
120        where
121            S: _serde::ser::Serializer,
122        {
123            let class_meta = self
124                .__ptr
125                .map(|name| (name, _serde::__private::Signature::new(0xcdec8025)));
126            let mut serializer = __serializer
127                .serialize_struct(
128                    "hkbStateMachineTransitionInfo",
129                    class_meta,
130                    (60u64, 72u64),
131                )?;
132            serializer.serialize_field("triggerInterval", &self.m_triggerInterval)?;
133            serializer.serialize_field("initiateInterval", &self.m_initiateInterval)?;
134            serializer.serialize_field("transition", &self.m_transition)?;
135            serializer.serialize_field("condition", &self.m_condition)?;
136            serializer.serialize_field("eventId", &self.m_eventId)?;
137            serializer.serialize_field("toStateId", &self.m_toStateId)?;
138            serializer.serialize_field("fromNestedStateId", &self.m_fromNestedStateId)?;
139            serializer.serialize_field("toNestedStateId", &self.m_toNestedStateId)?;
140            serializer.serialize_field("priority", &self.m_priority)?;
141            serializer.serialize_field("flags", &self.m_flags)?;
142            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
143            serializer.end()
144        }
145    }
146};
147#[doc(hidden)]
148#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
149const _: () = {
150    use havok_serde as _serde;
151    #[automatically_derived]
152    impl<'de> _serde::Deserialize<'de> for hkbStateMachineTransitionInfo {
153        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
154        where
155            __D: _serde::Deserializer<'de>,
156        {
157            #[allow(non_camel_case_types)]
158            enum __Field {
159                m_triggerInterval,
160                m_initiateInterval,
161                m_transition,
162                m_condition,
163                m_eventId,
164                m_toStateId,
165                m_fromNestedStateId,
166                m_toNestedStateId,
167                m_priority,
168                m_flags,
169                __ignore,
170            }
171            struct __FieldVisitor;
172            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
173                type Value = __Field;
174                fn expecting(
175                    &self,
176                    __formatter: &mut core::fmt::Formatter,
177                ) -> core::fmt::Result {
178                    core::fmt::Formatter::write_str(__formatter, "field identifier")
179                }
180                /// Intended for use in XML.
181                #[allow(clippy::match_single_binding)]
182                #[allow(clippy::reversed_empty_ranges)]
183                #[allow(clippy::single_match)]
184                fn visit_key<__E>(
185                    self,
186                    __value: &str,
187                ) -> core::result::Result<Self::Value, __E>
188                where
189                    __E: _serde::de::Error,
190                {
191                    match __value {
192                        "triggerInterval" => Ok(__Field::m_triggerInterval),
193                        "initiateInterval" => Ok(__Field::m_initiateInterval),
194                        "transition" => Ok(__Field::m_transition),
195                        "condition" => Ok(__Field::m_condition),
196                        "eventId" => Ok(__Field::m_eventId),
197                        "toStateId" => Ok(__Field::m_toStateId),
198                        "fromNestedStateId" => Ok(__Field::m_fromNestedStateId),
199                        "toNestedStateId" => Ok(__Field::m_toNestedStateId),
200                        "priority" => Ok(__Field::m_priority),
201                        "flags" => Ok(__Field::m_flags),
202                        _ => Ok(__Field::__ignore),
203                    }
204                }
205            }
206            impl<'de> _serde::Deserialize<'de> for __Field {
207                #[inline]
208                fn deserialize<__D>(
209                    __deserializer: __D,
210                ) -> core::result::Result<Self, __D::Error>
211                where
212                    __D: _serde::Deserializer<'de>,
213                {
214                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
215                }
216            }
217            struct __hkbStateMachineTransitionInfoVisitor<'de> {
218                marker: _serde::__private::PhantomData<hkbStateMachineTransitionInfo>,
219                lifetime: _serde::__private::PhantomData<&'de ()>,
220            }
221            #[allow(clippy::match_single_binding)]
222            #[allow(clippy::reversed_empty_ranges)]
223            #[allow(clippy::single_match)]
224            impl<'de> _serde::de::Visitor<'de>
225            for __hkbStateMachineTransitionInfoVisitor<'de> {
226                type Value = hkbStateMachineTransitionInfo;
227                fn expecting(
228                    &self,
229                    __formatter: &mut core::fmt::Formatter,
230                ) -> core::fmt::Result {
231                    core::fmt::Formatter::write_str(
232                        __formatter,
233                        "struct hkbStateMachineTransitionInfo",
234                    )
235                }
236                fn visit_struct_for_bytes<__A>(
237                    self,
238                    mut __map: __A,
239                ) -> _serde::__private::Result<Self::Value, __A::Error>
240                where
241                    __A: _serde::de::MapAccess<'de>,
242                {
243                    let __ptr = __A::class_ptr(&mut __map);
244                    let mut m_triggerInterval: _serde::__private::Option<
245                        hkbStateMachineTimeInterval,
246                    > = _serde::__private::None;
247                    let mut m_initiateInterval: _serde::__private::Option<
248                        hkbStateMachineTimeInterval,
249                    > = _serde::__private::None;
250                    let mut m_transition: _serde::__private::Option<Pointer> = _serde::__private::None;
251                    let mut m_condition: _serde::__private::Option<Pointer> = _serde::__private::None;
252                    let mut m_eventId: _serde::__private::Option<i32> = _serde::__private::None;
253                    let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
254                    let mut m_fromNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
255                    let mut m_toNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
256                    let mut m_priority: _serde::__private::Option<i16> = _serde::__private::None;
257                    let mut m_flags: _serde::__private::Option<TransitionFlags> = _serde::__private::None;
258                    for i in 0..10usize {
259                        match i {
260                            0usize => {
261                                if _serde::__private::Option::is_some(&m_triggerInterval) {
262                                    return _serde::__private::Err(
263                                        <__A::Error as _serde::de::Error>::duplicate_field(
264                                            "triggerInterval",
265                                        ),
266                                    );
267                                }
268                                m_triggerInterval = _serde::__private::Some(
269                                    match __A::next_value::<
270                                        hkbStateMachineTimeInterval,
271                                    >(&mut __map) {
272                                        _serde::__private::Ok(__val) => __val,
273                                        _serde::__private::Err(__err) => {
274                                            return _serde::__private::Err(__err);
275                                        }
276                                    },
277                                );
278                            }
279                            1usize => {
280                                if _serde::__private::Option::is_some(&m_initiateInterval) {
281                                    return _serde::__private::Err(
282                                        <__A::Error as _serde::de::Error>::duplicate_field(
283                                            "initiateInterval",
284                                        ),
285                                    );
286                                }
287                                m_initiateInterval = _serde::__private::Some(
288                                    match __A::next_value::<
289                                        hkbStateMachineTimeInterval,
290                                    >(&mut __map) {
291                                        _serde::__private::Ok(__val) => __val,
292                                        _serde::__private::Err(__err) => {
293                                            return _serde::__private::Err(__err);
294                                        }
295                                    },
296                                );
297                            }
298                            2usize => {
299                                if _serde::__private::Option::is_some(&m_transition) {
300                                    return _serde::__private::Err(
301                                        <__A::Error as _serde::de::Error>::duplicate_field(
302                                            "transition",
303                                        ),
304                                    );
305                                }
306                                m_transition = _serde::__private::Some(
307                                    match __A::next_value::<Pointer>(&mut __map) {
308                                        _serde::__private::Ok(__val) => __val,
309                                        _serde::__private::Err(__err) => {
310                                            return _serde::__private::Err(__err);
311                                        }
312                                    },
313                                );
314                            }
315                            3usize => {
316                                if _serde::__private::Option::is_some(&m_condition) {
317                                    return _serde::__private::Err(
318                                        <__A::Error as _serde::de::Error>::duplicate_field(
319                                            "condition",
320                                        ),
321                                    );
322                                }
323                                m_condition = _serde::__private::Some(
324                                    match __A::next_value::<Pointer>(&mut __map) {
325                                        _serde::__private::Ok(__val) => __val,
326                                        _serde::__private::Err(__err) => {
327                                            return _serde::__private::Err(__err);
328                                        }
329                                    },
330                                );
331                            }
332                            4usize => {
333                                if _serde::__private::Option::is_some(&m_eventId) {
334                                    return _serde::__private::Err(
335                                        <__A::Error as _serde::de::Error>::duplicate_field(
336                                            "eventId",
337                                        ),
338                                    );
339                                }
340                                m_eventId = _serde::__private::Some(
341                                    match __A::next_value::<i32>(&mut __map) {
342                                        _serde::__private::Ok(__val) => __val,
343                                        _serde::__private::Err(__err) => {
344                                            return _serde::__private::Err(__err);
345                                        }
346                                    },
347                                );
348                            }
349                            5usize => {
350                                if _serde::__private::Option::is_some(&m_toStateId) {
351                                    return _serde::__private::Err(
352                                        <__A::Error as _serde::de::Error>::duplicate_field(
353                                            "toStateId",
354                                        ),
355                                    );
356                                }
357                                m_toStateId = _serde::__private::Some(
358                                    match __A::next_value::<i32>(&mut __map) {
359                                        _serde::__private::Ok(__val) => __val,
360                                        _serde::__private::Err(__err) => {
361                                            return _serde::__private::Err(__err);
362                                        }
363                                    },
364                                );
365                            }
366                            6usize => {
367                                if _serde::__private::Option::is_some(
368                                    &m_fromNestedStateId,
369                                ) {
370                                    return _serde::__private::Err(
371                                        <__A::Error as _serde::de::Error>::duplicate_field(
372                                            "fromNestedStateId",
373                                        ),
374                                    );
375                                }
376                                m_fromNestedStateId = _serde::__private::Some(
377                                    match __A::next_value::<i32>(&mut __map) {
378                                        _serde::__private::Ok(__val) => __val,
379                                        _serde::__private::Err(__err) => {
380                                            return _serde::__private::Err(__err);
381                                        }
382                                    },
383                                );
384                            }
385                            7usize => {
386                                if _serde::__private::Option::is_some(&m_toNestedStateId) {
387                                    return _serde::__private::Err(
388                                        <__A::Error as _serde::de::Error>::duplicate_field(
389                                            "toNestedStateId",
390                                        ),
391                                    );
392                                }
393                                m_toNestedStateId = _serde::__private::Some(
394                                    match __A::next_value::<i32>(&mut __map) {
395                                        _serde::__private::Ok(__val) => __val,
396                                        _serde::__private::Err(__err) => {
397                                            return _serde::__private::Err(__err);
398                                        }
399                                    },
400                                );
401                            }
402                            8usize => {
403                                if _serde::__private::Option::is_some(&m_priority) {
404                                    return _serde::__private::Err(
405                                        <__A::Error as _serde::de::Error>::duplicate_field(
406                                            "priority",
407                                        ),
408                                    );
409                                }
410                                m_priority = _serde::__private::Some(
411                                    match __A::next_value::<i16>(&mut __map) {
412                                        _serde::__private::Ok(__val) => __val,
413                                        _serde::__private::Err(__err) => {
414                                            return _serde::__private::Err(__err);
415                                        }
416                                    },
417                                );
418                            }
419                            9usize => {
420                                if _serde::__private::Option::is_some(&m_flags) {
421                                    return _serde::__private::Err(
422                                        <__A::Error as _serde::de::Error>::duplicate_field("flags"),
423                                    );
424                                }
425                                m_flags = _serde::__private::Some(
426                                    match __A::next_value::<TransitionFlags>(&mut __map) {
427                                        _serde::__private::Ok(__val) => __val,
428                                        _serde::__private::Err(__err) => {
429                                            return _serde::__private::Err(__err);
430                                        }
431                                    },
432                                );
433                            }
434                            _ => {}
435                        }
436                    }
437                    __A::pad(&mut __map, 0usize, 4usize)?;
438                    let m_triggerInterval = match m_triggerInterval {
439                        _serde::__private::Some(__field) => __field,
440                        _serde::__private::None => {
441                            return _serde::__private::Err(
442                                <__A::Error as _serde::de::Error>::missing_field(
443                                    "triggerInterval",
444                                ),
445                            );
446                        }
447                    };
448                    let m_initiateInterval = match m_initiateInterval {
449                        _serde::__private::Some(__field) => __field,
450                        _serde::__private::None => {
451                            return _serde::__private::Err(
452                                <__A::Error as _serde::de::Error>::missing_field(
453                                    "initiateInterval",
454                                ),
455                            );
456                        }
457                    };
458                    let m_transition = match m_transition {
459                        _serde::__private::Some(__field) => __field,
460                        _serde::__private::None => {
461                            return _serde::__private::Err(
462                                <__A::Error as _serde::de::Error>::missing_field(
463                                    "transition",
464                                ),
465                            );
466                        }
467                    };
468                    let m_condition = match m_condition {
469                        _serde::__private::Some(__field) => __field,
470                        _serde::__private::None => {
471                            return _serde::__private::Err(
472                                <__A::Error as _serde::de::Error>::missing_field(
473                                    "condition",
474                                ),
475                            );
476                        }
477                    };
478                    let m_eventId = match m_eventId {
479                        _serde::__private::Some(__field) => __field,
480                        _serde::__private::None => {
481                            return _serde::__private::Err(
482                                <__A::Error as _serde::de::Error>::missing_field("eventId"),
483                            );
484                        }
485                    };
486                    let m_toStateId = match m_toStateId {
487                        _serde::__private::Some(__field) => __field,
488                        _serde::__private::None => {
489                            return _serde::__private::Err(
490                                <__A::Error as _serde::de::Error>::missing_field(
491                                    "toStateId",
492                                ),
493                            );
494                        }
495                    };
496                    let m_fromNestedStateId = match m_fromNestedStateId {
497                        _serde::__private::Some(__field) => __field,
498                        _serde::__private::None => {
499                            return _serde::__private::Err(
500                                <__A::Error as _serde::de::Error>::missing_field(
501                                    "fromNestedStateId",
502                                ),
503                            );
504                        }
505                    };
506                    let m_toNestedStateId = match m_toNestedStateId {
507                        _serde::__private::Some(__field) => __field,
508                        _serde::__private::None => {
509                            return _serde::__private::Err(
510                                <__A::Error as _serde::de::Error>::missing_field(
511                                    "toNestedStateId",
512                                ),
513                            );
514                        }
515                    };
516                    let m_priority = match m_priority {
517                        _serde::__private::Some(__field) => __field,
518                        _serde::__private::None => {
519                            return _serde::__private::Err(
520                                <__A::Error as _serde::de::Error>::missing_field("priority"),
521                            );
522                        }
523                    };
524                    let m_flags = match m_flags {
525                        _serde::__private::Some(__field) => __field,
526                        _serde::__private::None => {
527                            return _serde::__private::Err(
528                                <__A::Error as _serde::de::Error>::missing_field("flags"),
529                            );
530                        }
531                    };
532                    _serde::__private::Ok(hkbStateMachineTransitionInfo {
533                        __ptr,
534                        m_triggerInterval,
535                        m_initiateInterval,
536                        m_transition,
537                        m_condition,
538                        m_eventId,
539                        m_toStateId,
540                        m_fromNestedStateId,
541                        m_toNestedStateId,
542                        m_priority,
543                        m_flags,
544                    })
545                }
546                #[allow(clippy::manual_unwrap_or_default)]
547                fn visit_struct<__A>(
548                    self,
549                    mut __map: __A,
550                ) -> _serde::__private::Result<Self::Value, __A::Error>
551                where
552                    __A: _serde::de::MapAccess<'de>,
553                {
554                    let mut m_triggerInterval: _serde::__private::Option<
555                        hkbStateMachineTimeInterval,
556                    > = _serde::__private::None;
557                    let mut m_initiateInterval: _serde::__private::Option<
558                        hkbStateMachineTimeInterval,
559                    > = _serde::__private::None;
560                    let mut m_transition: _serde::__private::Option<Pointer> = _serde::__private::None;
561                    let mut m_condition: _serde::__private::Option<Pointer> = _serde::__private::None;
562                    let mut m_eventId: _serde::__private::Option<i32> = _serde::__private::None;
563                    let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
564                    let mut m_fromNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
565                    let mut m_toNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
566                    let mut m_priority: _serde::__private::Option<i16> = _serde::__private::None;
567                    let mut m_flags: _serde::__private::Option<TransitionFlags> = _serde::__private::None;
568                    while let _serde::__private::Some(__key) = {
569                        __A::next_key::<__Field>(&mut __map)?
570                    } {
571                        match __key {
572                            __Field::m_triggerInterval => {
573                                #[cfg(
574                                    any(feature = "strict", feature = "ignore_duplicates")
575                                )]
576                                if _serde::__private::Option::is_some(&m_triggerInterval) {
577                                    #[cfg(feature = "ignore_duplicates")]
578                                    {
579                                        __A::skip_value(&mut __map)?;
580                                        continue;
581                                    }
582                                    #[cfg(feature = "strict")]
583                                    return _serde::__private::Err(
584                                        <__A::Error as _serde::de::Error>::duplicate_field(
585                                            "triggerInterval",
586                                        ),
587                                    );
588                                }
589                                m_triggerInterval = _serde::__private::Some(
590                                    match __A::next_value::<
591                                        hkbStateMachineTimeInterval,
592                                    >(&mut __map) {
593                                        _serde::__private::Ok(__val) => __val,
594                                        _serde::__private::Err(__err) => {
595                                            return _serde::__private::Err(__err);
596                                        }
597                                    },
598                                );
599                            }
600                            __Field::m_initiateInterval => {
601                                #[cfg(
602                                    any(feature = "strict", feature = "ignore_duplicates")
603                                )]
604                                if _serde::__private::Option::is_some(&m_initiateInterval) {
605                                    #[cfg(feature = "ignore_duplicates")]
606                                    {
607                                        __A::skip_value(&mut __map)?;
608                                        continue;
609                                    }
610                                    #[cfg(feature = "strict")]
611                                    return _serde::__private::Err(
612                                        <__A::Error as _serde::de::Error>::duplicate_field(
613                                            "initiateInterval",
614                                        ),
615                                    );
616                                }
617                                m_initiateInterval = _serde::__private::Some(
618                                    match __A::next_value::<
619                                        hkbStateMachineTimeInterval,
620                                    >(&mut __map) {
621                                        _serde::__private::Ok(__val) => __val,
622                                        _serde::__private::Err(__err) => {
623                                            return _serde::__private::Err(__err);
624                                        }
625                                    },
626                                );
627                            }
628                            __Field::m_transition => {
629                                #[cfg(
630                                    any(feature = "strict", feature = "ignore_duplicates")
631                                )]
632                                if _serde::__private::Option::is_some(&m_transition) {
633                                    #[cfg(feature = "ignore_duplicates")]
634                                    {
635                                        __A::skip_value(&mut __map)?;
636                                        continue;
637                                    }
638                                    #[cfg(feature = "strict")]
639                                    return _serde::__private::Err(
640                                        <__A::Error as _serde::de::Error>::duplicate_field(
641                                            "transition",
642                                        ),
643                                    );
644                                }
645                                m_transition = _serde::__private::Some(
646                                    match __A::next_value::<Pointer>(&mut __map) {
647                                        _serde::__private::Ok(__val) => __val,
648                                        _serde::__private::Err(__err) => {
649                                            return _serde::__private::Err(__err);
650                                        }
651                                    },
652                                );
653                            }
654                            __Field::m_condition => {
655                                #[cfg(
656                                    any(feature = "strict", feature = "ignore_duplicates")
657                                )]
658                                if _serde::__private::Option::is_some(&m_condition) {
659                                    #[cfg(feature = "ignore_duplicates")]
660                                    {
661                                        __A::skip_value(&mut __map)?;
662                                        continue;
663                                    }
664                                    #[cfg(feature = "strict")]
665                                    return _serde::__private::Err(
666                                        <__A::Error as _serde::de::Error>::duplicate_field(
667                                            "condition",
668                                        ),
669                                    );
670                                }
671                                m_condition = _serde::__private::Some(
672                                    match __A::next_value::<Pointer>(&mut __map) {
673                                        _serde::__private::Ok(__val) => __val,
674                                        _serde::__private::Err(__err) => {
675                                            return _serde::__private::Err(__err);
676                                        }
677                                    },
678                                );
679                            }
680                            __Field::m_eventId => {
681                                #[cfg(
682                                    any(feature = "strict", feature = "ignore_duplicates")
683                                )]
684                                if _serde::__private::Option::is_some(&m_eventId) {
685                                    #[cfg(feature = "ignore_duplicates")]
686                                    {
687                                        __A::skip_value(&mut __map)?;
688                                        continue;
689                                    }
690                                    #[cfg(feature = "strict")]
691                                    return _serde::__private::Err(
692                                        <__A::Error as _serde::de::Error>::duplicate_field(
693                                            "eventId",
694                                        ),
695                                    );
696                                }
697                                m_eventId = _serde::__private::Some(
698                                    match __A::next_value::<i32>(&mut __map) {
699                                        _serde::__private::Ok(__val) => __val,
700                                        _serde::__private::Err(__err) => {
701                                            return _serde::__private::Err(__err);
702                                        }
703                                    },
704                                );
705                            }
706                            __Field::m_toStateId => {
707                                #[cfg(
708                                    any(feature = "strict", feature = "ignore_duplicates")
709                                )]
710                                if _serde::__private::Option::is_some(&m_toStateId) {
711                                    #[cfg(feature = "ignore_duplicates")]
712                                    {
713                                        __A::skip_value(&mut __map)?;
714                                        continue;
715                                    }
716                                    #[cfg(feature = "strict")]
717                                    return _serde::__private::Err(
718                                        <__A::Error as _serde::de::Error>::duplicate_field(
719                                            "toStateId",
720                                        ),
721                                    );
722                                }
723                                m_toStateId = _serde::__private::Some(
724                                    match __A::next_value::<i32>(&mut __map) {
725                                        _serde::__private::Ok(__val) => __val,
726                                        _serde::__private::Err(__err) => {
727                                            return _serde::__private::Err(__err);
728                                        }
729                                    },
730                                );
731                            }
732                            __Field::m_fromNestedStateId => {
733                                #[cfg(
734                                    any(feature = "strict", feature = "ignore_duplicates")
735                                )]
736                                if _serde::__private::Option::is_some(
737                                    &m_fromNestedStateId,
738                                ) {
739                                    #[cfg(feature = "ignore_duplicates")]
740                                    {
741                                        __A::skip_value(&mut __map)?;
742                                        continue;
743                                    }
744                                    #[cfg(feature = "strict")]
745                                    return _serde::__private::Err(
746                                        <__A::Error as _serde::de::Error>::duplicate_field(
747                                            "fromNestedStateId",
748                                        ),
749                                    );
750                                }
751                                m_fromNestedStateId = _serde::__private::Some(
752                                    match __A::next_value::<i32>(&mut __map) {
753                                        _serde::__private::Ok(__val) => __val,
754                                        _serde::__private::Err(__err) => {
755                                            return _serde::__private::Err(__err);
756                                        }
757                                    },
758                                );
759                            }
760                            __Field::m_toNestedStateId => {
761                                #[cfg(
762                                    any(feature = "strict", feature = "ignore_duplicates")
763                                )]
764                                if _serde::__private::Option::is_some(&m_toNestedStateId) {
765                                    #[cfg(feature = "ignore_duplicates")]
766                                    {
767                                        __A::skip_value(&mut __map)?;
768                                        continue;
769                                    }
770                                    #[cfg(feature = "strict")]
771                                    return _serde::__private::Err(
772                                        <__A::Error as _serde::de::Error>::duplicate_field(
773                                            "toNestedStateId",
774                                        ),
775                                    );
776                                }
777                                m_toNestedStateId = _serde::__private::Some(
778                                    match __A::next_value::<i32>(&mut __map) {
779                                        _serde::__private::Ok(__val) => __val,
780                                        _serde::__private::Err(__err) => {
781                                            return _serde::__private::Err(__err);
782                                        }
783                                    },
784                                );
785                            }
786                            __Field::m_priority => {
787                                #[cfg(
788                                    any(feature = "strict", feature = "ignore_duplicates")
789                                )]
790                                if _serde::__private::Option::is_some(&m_priority) {
791                                    #[cfg(feature = "ignore_duplicates")]
792                                    {
793                                        __A::skip_value(&mut __map)?;
794                                        continue;
795                                    }
796                                    #[cfg(feature = "strict")]
797                                    return _serde::__private::Err(
798                                        <__A::Error as _serde::de::Error>::duplicate_field(
799                                            "priority",
800                                        ),
801                                    );
802                                }
803                                m_priority = _serde::__private::Some(
804                                    match __A::next_value::<i16>(&mut __map) {
805                                        _serde::__private::Ok(__val) => __val,
806                                        _serde::__private::Err(__err) => {
807                                            return _serde::__private::Err(__err);
808                                        }
809                                    },
810                                );
811                            }
812                            __Field::m_flags => {
813                                #[cfg(
814                                    any(feature = "strict", feature = "ignore_duplicates")
815                                )]
816                                if _serde::__private::Option::is_some(&m_flags) {
817                                    #[cfg(feature = "ignore_duplicates")]
818                                    {
819                                        __A::skip_value(&mut __map)?;
820                                        continue;
821                                    }
822                                    #[cfg(feature = "strict")]
823                                    return _serde::__private::Err(
824                                        <__A::Error as _serde::de::Error>::duplicate_field("flags"),
825                                    );
826                                }
827                                m_flags = _serde::__private::Some(
828                                    match __A::next_value::<TransitionFlags>(&mut __map) {
829                                        _serde::__private::Ok(__val) => __val,
830                                        _serde::__private::Err(__err) => {
831                                            return _serde::__private::Err(__err);
832                                        }
833                                    },
834                                );
835                            }
836                            _ => __A::skip_value(&mut __map)?,
837                        }
838                    }
839                    let m_triggerInterval = match m_triggerInterval {
840                        _serde::__private::Some(__field) => __field,
841                        _serde::__private::None => {
842                            #[cfg(feature = "strict")]
843                            return _serde::__private::Err(
844                                <__A::Error as _serde::de::Error>::missing_field(
845                                    "triggerInterval",
846                                ),
847                            );
848                            #[cfg(not(feature = "strict"))] Default::default()
849                        }
850                    };
851                    let m_initiateInterval = match m_initiateInterval {
852                        _serde::__private::Some(__field) => __field,
853                        _serde::__private::None => {
854                            #[cfg(feature = "strict")]
855                            return _serde::__private::Err(
856                                <__A::Error as _serde::de::Error>::missing_field(
857                                    "initiateInterval",
858                                ),
859                            );
860                            #[cfg(not(feature = "strict"))] Default::default()
861                        }
862                    };
863                    let m_transition = match m_transition {
864                        _serde::__private::Some(__field) => __field,
865                        _serde::__private::None => {
866                            #[cfg(feature = "strict")]
867                            return _serde::__private::Err(
868                                <__A::Error as _serde::de::Error>::missing_field(
869                                    "transition",
870                                ),
871                            );
872                            #[cfg(not(feature = "strict"))] Default::default()
873                        }
874                    };
875                    let m_condition = match m_condition {
876                        _serde::__private::Some(__field) => __field,
877                        _serde::__private::None => {
878                            #[cfg(feature = "strict")]
879                            return _serde::__private::Err(
880                                <__A::Error as _serde::de::Error>::missing_field(
881                                    "condition",
882                                ),
883                            );
884                            #[cfg(not(feature = "strict"))] Default::default()
885                        }
886                    };
887                    let m_eventId = match m_eventId {
888                        _serde::__private::Some(__field) => __field,
889                        _serde::__private::None => {
890                            #[cfg(feature = "strict")]
891                            return _serde::__private::Err(
892                                <__A::Error as _serde::de::Error>::missing_field("eventId"),
893                            );
894                            #[cfg(not(feature = "strict"))] Default::default()
895                        }
896                    };
897                    let m_toStateId = match m_toStateId {
898                        _serde::__private::Some(__field) => __field,
899                        _serde::__private::None => {
900                            #[cfg(feature = "strict")]
901                            return _serde::__private::Err(
902                                <__A::Error as _serde::de::Error>::missing_field(
903                                    "toStateId",
904                                ),
905                            );
906                            #[cfg(not(feature = "strict"))] Default::default()
907                        }
908                    };
909                    let m_fromNestedStateId = match m_fromNestedStateId {
910                        _serde::__private::Some(__field) => __field,
911                        _serde::__private::None => {
912                            #[cfg(feature = "strict")]
913                            return _serde::__private::Err(
914                                <__A::Error as _serde::de::Error>::missing_field(
915                                    "fromNestedStateId",
916                                ),
917                            );
918                            #[cfg(not(feature = "strict"))] Default::default()
919                        }
920                    };
921                    let m_toNestedStateId = match m_toNestedStateId {
922                        _serde::__private::Some(__field) => __field,
923                        _serde::__private::None => {
924                            #[cfg(feature = "strict")]
925                            return _serde::__private::Err(
926                                <__A::Error as _serde::de::Error>::missing_field(
927                                    "toNestedStateId",
928                                ),
929                            );
930                            #[cfg(not(feature = "strict"))] Default::default()
931                        }
932                    };
933                    let m_priority = match m_priority {
934                        _serde::__private::Some(__field) => __field,
935                        _serde::__private::None => {
936                            #[cfg(feature = "strict")]
937                            return _serde::__private::Err(
938                                <__A::Error as _serde::de::Error>::missing_field("priority"),
939                            );
940                            #[cfg(not(feature = "strict"))] Default::default()
941                        }
942                    };
943                    let m_flags = match m_flags {
944                        _serde::__private::Some(__field) => __field,
945                        _serde::__private::None => {
946                            #[cfg(feature = "strict")]
947                            return _serde::__private::Err(
948                                <__A::Error as _serde::de::Error>::missing_field("flags"),
949                            );
950                            #[cfg(not(feature = "strict"))] Default::default()
951                        }
952                    };
953                    let __ptr = __A::class_ptr(&mut __map);
954                    _serde::__private::Ok(hkbStateMachineTransitionInfo {
955                        __ptr,
956                        m_triggerInterval,
957                        m_initiateInterval,
958                        m_transition,
959                        m_condition,
960                        m_eventId,
961                        m_toStateId,
962                        m_fromNestedStateId,
963                        m_toNestedStateId,
964                        m_priority,
965                        m_flags,
966                    })
967                }
968            }
969            const FIELDS: &[&str] = &[
970                "triggerInterval",
971                "initiateInterval",
972                "transition",
973                "condition",
974                "eventId",
975                "toStateId",
976                "fromNestedStateId",
977                "toNestedStateId",
978                "priority",
979                "flags",
980            ];
981            _serde::Deserializer::deserialize_struct(
982                deserializer,
983                "hkbStateMachineTransitionInfo",
984                FIELDS,
985                __hkbStateMachineTransitionInfoVisitor {
986                    marker: _serde::__private::PhantomData::<
987                        hkbStateMachineTransitionInfo,
988                    >,
989                    lifetime: _serde::__private::PhantomData,
990                },
991            )
992        }
993    }
994};
995#[havok_types_derive::impl_flags_methods]
996bitflags::bitflags! {
997    #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
998    " - name: `TransitionFlags`(ctype: `hkFlags<TransitionFlags, hkInt16>`)"]
999    #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
1000    derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
1001    #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
1002    TransitionFlags : i16 { #[doc = "1"] const FLAG_USE_TRIGGER_INTERVAL = 1i16; #[doc =
1003    "2"] const FLAG_USE_INITIATE_INTERVAL = 2i16; #[doc = "4"] const
1004    FLAG_UNINTERRUPTIBLE_WHILE_PLAYING = 4i16; #[doc = "8"] const
1005    FLAG_UNINTERRUPTIBLE_WHILE_DELAYED = 8i16; #[doc = "16"] const
1006    FLAG_DELAY_STATE_CHANGE = 16i16; #[doc = "32"] const FLAG_DISABLED = 32i16; #[doc =
1007    "64"] const FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE = 64i16; #[doc = "128"] const
1008    FLAG_DISALLOW_RANDOM_TRANSITION = 128i16; #[doc = "256"] const FLAG_DISABLE_CONDITION
1009    = 256i16; #[doc = "512"] const
1010    FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE = 512i16; #[doc = "1024"]
1011    const FLAG_IS_GLOBAL_WILDCARD = 1024i16; #[doc = "2048"] const FLAG_IS_LOCAL_WILDCARD
1012    = 2048i16; #[doc = "4096"] const FLAG_FROM_NESTED_STATE_ID_IS_VALID = 4096i16; #[doc
1013    = "8192"] const FLAG_TO_NESTED_STATE_ID_IS_VALID = 8192i16; #[doc = "16384"] const
1014    FLAG_ABUT_AT_END_OF_FROM_GENERATOR = 16384i16; }
1015}
1016#[cfg(feature = "json_schema")]
1017const _: () = {
1018    use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
1019    use std::borrow::Cow;
1020    impl JsonSchema for TransitionFlags {
1021        fn schema_name() -> Cow<'static, str> {
1022            "TransitionFlags".into()
1023        }
1024        fn schema_id() -> Cow<'static, str> {
1025            concat!(module_path!(), "::", "TransitionFlags").into()
1026        }
1027        fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
1028            json_schema!(
1029                { "description" :
1030                "Bitflags field. Specific flags: FLAG_USE_TRIGGER_INTERVAL: 1, FLAG_USE_INITIATE_INTERVAL: 2, FLAG_UNINTERRUPTIBLE_WHILE_PLAYING: 4, FLAG_UNINTERRUPTIBLE_WHILE_DELAYED: 8, FLAG_DELAY_STATE_CHANGE: 16, FLAG_DISABLED: 32, FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE: 64, FLAG_DISALLOW_RANDOM_TRANSITION: 128, FLAG_DISABLE_CONDITION: 256, FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE: 512, FLAG_IS_GLOBAL_WILDCARD: 1024, FLAG_IS_LOCAL_WILDCARD: 2048, FLAG_FROM_NESTED_STATE_ID_IS_VALID: 4096, FLAG_TO_NESTED_STATE_ID_IS_VALID: 8192, FLAG_ABUT_AT_END_OF_FROM_GENERATOR: 16384. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
1031                "type" : "string", }
1032            )
1033        }
1034    }
1035};
1036const _: () = {
1037    use havok_serde as __serde;
1038    impl __serde::Serialize for TransitionFlags {
1039        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1040        where
1041            S: __serde::ser::Serializer,
1042        {
1043            let mut __serializer = __serializer.serialize_enum_flags()?;
1044            if self.is_empty() {
1045                __serializer.serialize_bits(&self.bits())?;
1046                __serializer.serialize_empty_bit()?;
1047                return __serializer.end();
1048            }
1049            for flag in self.iter() {
1050                match flag {
1051                    Self::FLAG_USE_TRIGGER_INTERVAL => {
1052                        __serializer
1053                            .serialize_field(
1054                                "FLAG_USE_TRIGGER_INTERVAL",
1055                                &Self::FLAG_USE_TRIGGER_INTERVAL,
1056                            )
1057                    }
1058                    Self::FLAG_USE_INITIATE_INTERVAL => {
1059                        __serializer
1060                            .serialize_field(
1061                                "FLAG_USE_INITIATE_INTERVAL",
1062                                &Self::FLAG_USE_INITIATE_INTERVAL,
1063                            )
1064                    }
1065                    Self::FLAG_UNINTERRUPTIBLE_WHILE_PLAYING => {
1066                        __serializer
1067                            .serialize_field(
1068                                "FLAG_UNINTERRUPTIBLE_WHILE_PLAYING",
1069                                &Self::FLAG_UNINTERRUPTIBLE_WHILE_PLAYING,
1070                            )
1071                    }
1072                    Self::FLAG_UNINTERRUPTIBLE_WHILE_DELAYED => {
1073                        __serializer
1074                            .serialize_field(
1075                                "FLAG_UNINTERRUPTIBLE_WHILE_DELAYED",
1076                                &Self::FLAG_UNINTERRUPTIBLE_WHILE_DELAYED,
1077                            )
1078                    }
1079                    Self::FLAG_DELAY_STATE_CHANGE => {
1080                        __serializer
1081                            .serialize_field(
1082                                "FLAG_DELAY_STATE_CHANGE",
1083                                &Self::FLAG_DELAY_STATE_CHANGE,
1084                            )
1085                    }
1086                    Self::FLAG_DISABLED => {
1087                        __serializer
1088                            .serialize_field("FLAG_DISABLED", &Self::FLAG_DISABLED)
1089                    }
1090                    Self::FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE => {
1091                        __serializer
1092                            .serialize_field(
1093                                "FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE",
1094                                &Self::FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE,
1095                            )
1096                    }
1097                    Self::FLAG_DISALLOW_RANDOM_TRANSITION => {
1098                        __serializer
1099                            .serialize_field(
1100                                "FLAG_DISALLOW_RANDOM_TRANSITION",
1101                                &Self::FLAG_DISALLOW_RANDOM_TRANSITION,
1102                            )
1103                    }
1104                    Self::FLAG_DISABLE_CONDITION => {
1105                        __serializer
1106                            .serialize_field(
1107                                "FLAG_DISABLE_CONDITION",
1108                                &Self::FLAG_DISABLE_CONDITION,
1109                            )
1110                    }
1111                    Self::FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE => {
1112                        __serializer
1113                            .serialize_field(
1114                                "FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE",
1115                                &Self::FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE,
1116                            )
1117                    }
1118                    Self::FLAG_IS_GLOBAL_WILDCARD => {
1119                        __serializer
1120                            .serialize_field(
1121                                "FLAG_IS_GLOBAL_WILDCARD",
1122                                &Self::FLAG_IS_GLOBAL_WILDCARD,
1123                            )
1124                    }
1125                    Self::FLAG_IS_LOCAL_WILDCARD => {
1126                        __serializer
1127                            .serialize_field(
1128                                "FLAG_IS_LOCAL_WILDCARD",
1129                                &Self::FLAG_IS_LOCAL_WILDCARD,
1130                            )
1131                    }
1132                    Self::FLAG_FROM_NESTED_STATE_ID_IS_VALID => {
1133                        __serializer
1134                            .serialize_field(
1135                                "FLAG_FROM_NESTED_STATE_ID_IS_VALID",
1136                                &Self::FLAG_FROM_NESTED_STATE_ID_IS_VALID,
1137                            )
1138                    }
1139                    Self::FLAG_TO_NESTED_STATE_ID_IS_VALID => {
1140                        __serializer
1141                            .serialize_field(
1142                                "FLAG_TO_NESTED_STATE_ID_IS_VALID",
1143                                &Self::FLAG_TO_NESTED_STATE_ID_IS_VALID,
1144                            )
1145                    }
1146                    Self::FLAG_ABUT_AT_END_OF_FROM_GENERATOR => {
1147                        __serializer
1148                            .serialize_field(
1149                                "FLAG_ABUT_AT_END_OF_FROM_GENERATOR",
1150                                &Self::FLAG_ABUT_AT_END_OF_FROM_GENERATOR,
1151                            )
1152                    }
1153                    remain => {
1154                        __serializer
1155                            .serialize_field(&remain.bits().to_string(), &remain.bits())
1156                    }
1157                }?;
1158            }
1159            __serializer.serialize_bits(&self.bits())?;
1160            __serializer.end()
1161        }
1162    }
1163};
1164#[doc(hidden)]
1165#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1166const _: () = {
1167    #[allow(unused_extern_crates, clippy::useless_attribute)]
1168    extern crate havok_serde as _serde;
1169    #[automatically_derived]
1170    impl<'de> _serde::Deserialize<'de> for TransitionFlags {
1171        fn deserialize<__D>(
1172            __deserializer: __D,
1173        ) -> _serde::__private::Result<Self, __D::Error>
1174        where
1175            __D: _serde::Deserializer<'de>,
1176        {
1177            #[doc(hidden)]
1178            struct __Visitor<'de> {
1179                marker: _serde::__private::PhantomData<TransitionFlags>,
1180                lifetime: _serde::__private::PhantomData<&'de ()>,
1181            }
1182            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1183                type Value = TransitionFlags;
1184                fn expecting(
1185                    &self,
1186                    __formatter: &mut _serde::__private::Formatter,
1187                ) -> _serde::__private::fmt::Result {
1188                    _serde::__private::Formatter::write_str(
1189                        __formatter,
1190                        "struct TransitionFlags(flags)",
1191                    )
1192                }
1193                #[inline]
1194                fn visit_int16<__E>(
1195                    self,
1196                    __value: i16,
1197                ) -> _serde::__private::Result<Self::Value, __E>
1198                where
1199                    __E: _serde::de::Error,
1200                {
1201                    Ok(TransitionFlags::from_bits_retain(__value as _))
1202                }
1203                fn visit_stringptr<__E>(
1204                    self,
1205                    __value: StringPtr<'de>,
1206                ) -> _serde::__private::Result<Self::Value, __E>
1207                where
1208                    __E: _serde::de::Error,
1209                {
1210                    match <TransitionFlags as core::str::FromStr>::from_str(
1211                        __value.into_inner().unwrap().as_ref(),
1212                    ) {
1213                        Ok(flags) => Ok(flags),
1214                        Err(err) => Err(_serde::de::Error::custom(err)),
1215                    }
1216                }
1217            }
1218            _serde::Deserializer::deserialize_flags(
1219                __deserializer,
1220                _serde::de::ReadEnumSize::Int16,
1221                __Visitor {
1222                    marker: _serde::__private::PhantomData::<TransitionFlags>,
1223                    lifetime: _serde::__private::PhantomData,
1224                },
1225            )
1226        }
1227    }
1228};