havok_classes/generated/
hkbStateMachine_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbStateMachine`
5/// - version: `4`
6/// - signature: `0x816c1dcb`
7/// - size: `180`(x86)/`264`(x86_64)
8/// -  vtable: `true`
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 hkbStateMachine<'a> {
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    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbGenerator<'a>,
31    /// # C++ Info
32    /// - name: `eventToSendWhenStateOrTransitionChanges`(ctype: `struct hkbEvent`)
33    /// - offset: ` 40`(x86)/` 72`(x86_64)
34    /// - type_size: ` 12`(x86)/` 24`(x86_64)
35    #[cfg_attr(
36        feature = "json_schema",
37        schemars(rename = "eventToSendWhenStateOrTransitionChanges")
38    )]
39    #[cfg_attr(
40        feature = "serde",
41        serde(rename = "eventToSendWhenStateOrTransitionChanges")
42    )]
43    pub m_eventToSendWhenStateOrTransitionChanges: hkbEvent,
44    /// # C++ Info
45    /// - name: `startStateChooser`(ctype: `struct hkbStateChooser*`)
46    /// - offset: ` 52`(x86)/` 96`(x86_64)
47    /// - type_size: `  4`(x86)/`  8`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "startStateChooser"))]
49    #[cfg_attr(feature = "serde", serde(rename = "startStateChooser"))]
50    pub m_startStateChooser: Pointer,
51    /// # C++ Info
52    /// - name: `startStateId`(ctype: `hkInt32`)
53    /// - offset: ` 56`(x86)/`104`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "startStateId"))]
56    #[cfg_attr(feature = "serde", serde(rename = "startStateId"))]
57    pub m_startStateId: i32,
58    /// # C++ Info
59    /// - name: `returnToPreviousStateEventId`(ctype: `hkInt32`)
60    /// - offset: ` 60`(x86)/`108`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(
63        feature = "json_schema",
64        schemars(rename = "returnToPreviousStateEventId")
65    )]
66    #[cfg_attr(feature = "serde", serde(rename = "returnToPreviousStateEventId"))]
67    pub m_returnToPreviousStateEventId: i32,
68    /// # C++ Info
69    /// - name: `randomTransitionEventId`(ctype: `hkInt32`)
70    /// - offset: ` 64`(x86)/`112`(x86_64)
71    /// - type_size: `  4`(x86)/`  4`(x86_64)
72    #[cfg_attr(feature = "json_schema", schemars(rename = "randomTransitionEventId"))]
73    #[cfg_attr(feature = "serde", serde(rename = "randomTransitionEventId"))]
74    pub m_randomTransitionEventId: i32,
75    /// # C++ Info
76    /// - name: `transitionToNextHigherStateEventId`(ctype: `hkInt32`)
77    /// - offset: ` 68`(x86)/`116`(x86_64)
78    /// - type_size: `  4`(x86)/`  4`(x86_64)
79    #[cfg_attr(
80        feature = "json_schema",
81        schemars(rename = "transitionToNextHigherStateEventId")
82    )]
83    #[cfg_attr(feature = "serde", serde(rename = "transitionToNextHigherStateEventId"))]
84    pub m_transitionToNextHigherStateEventId: i32,
85    /// # C++ Info
86    /// - name: `transitionToNextLowerStateEventId`(ctype: `hkInt32`)
87    /// - offset: ` 72`(x86)/`120`(x86_64)
88    /// - type_size: `  4`(x86)/`  4`(x86_64)
89    #[cfg_attr(
90        feature = "json_schema",
91        schemars(rename = "transitionToNextLowerStateEventId")
92    )]
93    #[cfg_attr(feature = "serde", serde(rename = "transitionToNextLowerStateEventId"))]
94    pub m_transitionToNextLowerStateEventId: i32,
95    /// # C++ Info
96    /// - name: `syncVariableIndex`(ctype: `hkInt32`)
97    /// - offset: ` 76`(x86)/`124`(x86_64)
98    /// - type_size: `  4`(x86)/`  4`(x86_64)
99    #[cfg_attr(feature = "json_schema", schemars(rename = "syncVariableIndex"))]
100    #[cfg_attr(feature = "serde", serde(rename = "syncVariableIndex"))]
101    pub m_syncVariableIndex: i32,
102    /// # C++ Info
103    /// - name: `currentStateId`(ctype: `hkInt32`)
104    /// - offset: ` 80`(x86)/`128`(x86_64)
105    /// - type_size: `  4`(x86)/`  4`(x86_64)
106    /// - flags: `SERIALIZE_IGNORED`
107    #[cfg_attr(feature = "json_schema", schemars(rename = "currentStateId"))]
108    #[cfg_attr(feature = "serde", serde(rename = "currentStateId"))]
109    pub m_currentStateId: i32,
110    /// # C++ Info
111    /// - name: `wrapAroundStateId`(ctype: `hkBool`)
112    /// - offset: ` 84`(x86)/`132`(x86_64)
113    /// - type_size: `  1`(x86)/`  1`(x86_64)
114    #[cfg_attr(feature = "json_schema", schemars(rename = "wrapAroundStateId"))]
115    #[cfg_attr(feature = "serde", serde(rename = "wrapAroundStateId"))]
116    pub m_wrapAroundStateId: bool,
117    /// # C++ Info
118    /// - name: `maxSimultaneousTransitions`(ctype: `hkInt8`)
119    /// - offset: ` 85`(x86)/`133`(x86_64)
120    /// - type_size: `  1`(x86)/`  1`(x86_64)
121    #[cfg_attr(feature = "json_schema", schemars(rename = "maxSimultaneousTransitions"))]
122    #[cfg_attr(feature = "serde", serde(rename = "maxSimultaneousTransitions"))]
123    pub m_maxSimultaneousTransitions: i8,
124    /// # C++ Info
125    /// - name: `startStateMode`(ctype: `enum StartStateMode`)
126    /// - offset: ` 86`(x86)/`134`(x86_64)
127    /// - type_size: `  1`(x86)/`  1`(x86_64)
128    #[cfg_attr(feature = "json_schema", schemars(rename = "startStateMode"))]
129    #[cfg_attr(feature = "serde", serde(rename = "startStateMode"))]
130    pub m_startStateMode: StartStateMode,
131    /// # C++ Info
132    /// - name: `selfTransitionMode`(ctype: `enum StateMachineSelfTransitionMode`)
133    /// - offset: ` 87`(x86)/`135`(x86_64)
134    /// - type_size: `  1`(x86)/`  1`(x86_64)
135    #[cfg_attr(feature = "json_schema", schemars(rename = "selfTransitionMode"))]
136    #[cfg_attr(feature = "serde", serde(rename = "selfTransitionMode"))]
137    pub m_selfTransitionMode: StateMachineSelfTransitionMode,
138    /// # C++ Info
139    /// - name: `isActive`(ctype: `hkBool`)
140    /// - offset: ` 88`(x86)/`136`(x86_64)
141    /// - type_size: `  1`(x86)/`  1`(x86_64)
142    /// - flags: `SERIALIZE_IGNORED`
143    #[cfg_attr(feature = "json_schema", schemars(rename = "isActive"))]
144    #[cfg_attr(feature = "serde", serde(rename = "isActive"))]
145    pub m_isActive: bool,
146    /// # C++ Info
147    /// - name: `states`(ctype: `hkArray<hkbStateMachineStateInfo*>`)
148    /// - offset: ` 92`(x86)/`144`(x86_64)
149    /// - type_size: ` 12`(x86)/` 16`(x86_64)
150    #[cfg_attr(feature = "json_schema", schemars(rename = "states"))]
151    #[cfg_attr(feature = "serde", serde(rename = "states"))]
152    pub m_states: Vec<Pointer>,
153    /// # C++ Info
154    /// - name: `wildcardTransitions`(ctype: `struct hkbStateMachineTransitionInfoArray*`)
155    /// - offset: `104`(x86)/`160`(x86_64)
156    /// - type_size: `  4`(x86)/`  8`(x86_64)
157    #[cfg_attr(feature = "json_schema", schemars(rename = "wildcardTransitions"))]
158    #[cfg_attr(feature = "serde", serde(rename = "wildcardTransitions"))]
159    pub m_wildcardTransitions: Pointer,
160    /// # C++ Info
161    /// - name: `stateIdToIndexMap`(ctype: `void*`)
162    /// - offset: `108`(x86)/`168`(x86_64)
163    /// - type_size: `  4`(x86)/`  8`(x86_64)
164    /// - flags: `SERIALIZE_IGNORED`
165    #[cfg_attr(feature = "json_schema", schemars(rename = "stateIdToIndexMap"))]
166    #[cfg_attr(feature = "serde", serde(rename = "stateIdToIndexMap"))]
167    pub m_stateIdToIndexMap: Pointer,
168    /// # C++ Info
169    /// - name: `activeTransitions`(ctype: `hkArray<void>`)
170    /// - offset: `112`(x86)/`176`(x86_64)
171    /// - type_size: ` 12`(x86)/` 16`(x86_64)
172    /// - flags: `SERIALIZE_IGNORED`
173    #[cfg_attr(feature = "json_schema", schemars(rename = "activeTransitions"))]
174    #[cfg_attr(feature = "serde", serde(rename = "activeTransitions"))]
175    pub m_activeTransitions: Vec<()>,
176    /// # C++ Info
177    /// - name: `transitionFlags`(ctype: `hkArray<void>`)
178    /// - offset: `124`(x86)/`192`(x86_64)
179    /// - type_size: ` 12`(x86)/` 16`(x86_64)
180    /// - flags: `SERIALIZE_IGNORED`
181    #[cfg_attr(feature = "json_schema", schemars(rename = "transitionFlags"))]
182    #[cfg_attr(feature = "serde", serde(rename = "transitionFlags"))]
183    pub m_transitionFlags: Vec<()>,
184    /// # C++ Info
185    /// - name: `wildcardTransitionFlags`(ctype: `hkArray<void>`)
186    /// - offset: `136`(x86)/`208`(x86_64)
187    /// - type_size: ` 12`(x86)/` 16`(x86_64)
188    /// - flags: `SERIALIZE_IGNORED`
189    #[cfg_attr(feature = "json_schema", schemars(rename = "wildcardTransitionFlags"))]
190    #[cfg_attr(feature = "serde", serde(rename = "wildcardTransitionFlags"))]
191    pub m_wildcardTransitionFlags: Vec<()>,
192    /// # C++ Info
193    /// - name: `delayedTransitions`(ctype: `hkArray<void>`)
194    /// - offset: `148`(x86)/`224`(x86_64)
195    /// - type_size: ` 12`(x86)/` 16`(x86_64)
196    /// - flags: `SERIALIZE_IGNORED`
197    #[cfg_attr(feature = "json_schema", schemars(rename = "delayedTransitions"))]
198    #[cfg_attr(feature = "serde", serde(rename = "delayedTransitions"))]
199    pub m_delayedTransitions: Vec<()>,
200    /// # C++ Info
201    /// - name: `timeInState`(ctype: `hkReal`)
202    /// - offset: `160`(x86)/`240`(x86_64)
203    /// - type_size: `  4`(x86)/`  4`(x86_64)
204    /// - flags: `SERIALIZE_IGNORED`
205    #[cfg_attr(feature = "json_schema", schemars(rename = "timeInState"))]
206    #[cfg_attr(feature = "serde", serde(rename = "timeInState"))]
207    pub m_timeInState: f32,
208    /// # C++ Info
209    /// - name: `lastLocalTime`(ctype: `hkReal`)
210    /// - offset: `164`(x86)/`244`(x86_64)
211    /// - type_size: `  4`(x86)/`  4`(x86_64)
212    /// - flags: `SERIALIZE_IGNORED`
213    #[cfg_attr(feature = "json_schema", schemars(rename = "lastLocalTime"))]
214    #[cfg_attr(feature = "serde", serde(rename = "lastLocalTime"))]
215    pub m_lastLocalTime: f32,
216    /// # C++ Info
217    /// - name: `previousStateId`(ctype: `hkInt32`)
218    /// - offset: `168`(x86)/`248`(x86_64)
219    /// - type_size: `  4`(x86)/`  4`(x86_64)
220    /// - flags: `SERIALIZE_IGNORED`
221    #[cfg_attr(feature = "json_schema", schemars(rename = "previousStateId"))]
222    #[cfg_attr(feature = "serde", serde(rename = "previousStateId"))]
223    pub m_previousStateId: i32,
224    /// # C++ Info
225    /// - name: `nextStartStateIndexOverride`(ctype: `hkInt32`)
226    /// - offset: `172`(x86)/`252`(x86_64)
227    /// - type_size: `  4`(x86)/`  4`(x86_64)
228    /// - flags: `SERIALIZE_IGNORED`
229    #[cfg_attr(
230        feature = "json_schema",
231        schemars(rename = "nextStartStateIndexOverride")
232    )]
233    #[cfg_attr(feature = "serde", serde(rename = "nextStartStateIndexOverride"))]
234    pub m_nextStartStateIndexOverride: i32,
235    /// # C++ Info
236    /// - name: `stateOrTransitionChanged`(ctype: `hkBool`)
237    /// - offset: `176`(x86)/`256`(x86_64)
238    /// - type_size: `  1`(x86)/`  1`(x86_64)
239    /// - flags: `SERIALIZE_IGNORED`
240    #[cfg_attr(feature = "json_schema", schemars(rename = "stateOrTransitionChanged"))]
241    #[cfg_attr(feature = "serde", serde(rename = "stateOrTransitionChanged"))]
242    pub m_stateOrTransitionChanged: bool,
243    /// # C++ Info
244    /// - name: `echoNextUpdate`(ctype: `hkBool`)
245    /// - offset: `177`(x86)/`257`(x86_64)
246    /// - type_size: `  1`(x86)/`  1`(x86_64)
247    /// - flags: `SERIALIZE_IGNORED`
248    #[cfg_attr(feature = "json_schema", schemars(rename = "echoNextUpdate"))]
249    #[cfg_attr(feature = "serde", serde(rename = "echoNextUpdate"))]
250    pub m_echoNextUpdate: bool,
251    /// # C++ Info
252    /// - name: `sCurrentStateIndexAndEntered`(ctype: `hkUint16`)
253    /// - offset: `178`(x86)/`258`(x86_64)
254    /// - type_size: `  2`(x86)/`  2`(x86_64)
255    /// - flags: `SERIALIZE_IGNORED`
256    #[cfg_attr(
257        feature = "json_schema",
258        schemars(rename = "sCurrentStateIndexAndEntered")
259    )]
260    #[cfg_attr(feature = "serde", serde(rename = "sCurrentStateIndexAndEntered"))]
261    pub m_sCurrentStateIndexAndEntered: u16,
262}
263const _: () = {
264    use havok_serde as _serde;
265    impl<'a> _serde::HavokClass for hkbStateMachine<'a> {
266        #[inline]
267        fn name(&self) -> &'static str {
268            "hkbStateMachine"
269        }
270        #[inline]
271        fn signature(&self) -> _serde::__private::Signature {
272            _serde::__private::Signature::new(0x816c1dcb)
273        }
274        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
275        fn deps_indexes(&self) -> Vec<usize> {
276            let mut v = Vec::new();
277            v.push(self.parent.parent.parent.m_variableBindingSet.get());
278            v.extend(self.m_eventToSendWhenStateOrTransitionChanges.deps_indexes());
279            v.push(self.m_startStateChooser.get());
280            v.extend(self.m_states.iter().map(|ptr| ptr.get()));
281            v.push(self.m_wildcardTransitions.get());
282            v.push(self.m_stateIdToIndexMap.get());
283            v
284        }
285    }
286    impl<'a> _serde::Serialize for hkbStateMachine<'a> {
287        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
288        where
289            S: _serde::ser::Serializer,
290        {
291            let class_meta = self
292                .__ptr
293                .map(|name| (name, _serde::__private::Signature::new(0x816c1dcb)));
294            let mut serializer = __serializer
295                .serialize_struct("hkbStateMachine", class_meta, (180u64, 264u64))?;
296            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
297            serializer
298                .skip_field(
299                    "memSizeAndFlags",
300                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
301                )?;
302            serializer
303                .skip_field(
304                    "referenceCount",
305                    &self.parent.parent.parent.parent.m_referenceCount,
306                )?;
307            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
308            serializer
309                .serialize_field(
310                    "variableBindingSet",
311                    &self.parent.parent.parent.m_variableBindingSet,
312                )?;
313            serializer
314                .skip_array_field(
315                    "cachedBindables",
316                    &self.parent.parent.parent.m_cachedBindables,
317                    TypeSize::NonPtr,
318                )?;
319            serializer
320                .skip_field(
321                    "areBindablesCached",
322                    &self.parent.parent.parent.m_areBindablesCached,
323                )?;
324            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
325            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
326            serializer.serialize_field("name", &self.parent.parent.m_name)?;
327            serializer.skip_field("id", &self.parent.parent.m_id)?;
328            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
329            serializer
330                .skip_fixed_array_field(
331                    "padNode",
332                    self.parent.parent.m_padNode.as_slice(),
333                    TypeSize::NonPtr,
334                )?;
335            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
336            serializer
337                .serialize_field(
338                    "eventToSendWhenStateOrTransitionChanges",
339                    &self.m_eventToSendWhenStateOrTransitionChanges,
340                )?;
341            serializer.serialize_field("startStateChooser", &self.m_startStateChooser)?;
342            serializer.serialize_field("startStateId", &self.m_startStateId)?;
343            serializer
344                .serialize_field(
345                    "returnToPreviousStateEventId",
346                    &self.m_returnToPreviousStateEventId,
347                )?;
348            serializer
349                .serialize_field(
350                    "randomTransitionEventId",
351                    &self.m_randomTransitionEventId,
352                )?;
353            serializer
354                .serialize_field(
355                    "transitionToNextHigherStateEventId",
356                    &self.m_transitionToNextHigherStateEventId,
357                )?;
358            serializer
359                .serialize_field(
360                    "transitionToNextLowerStateEventId",
361                    &self.m_transitionToNextLowerStateEventId,
362                )?;
363            serializer.serialize_field("syncVariableIndex", &self.m_syncVariableIndex)?;
364            serializer.skip_field("currentStateId", &self.m_currentStateId)?;
365            serializer.serialize_field("wrapAroundStateId", &self.m_wrapAroundStateId)?;
366            serializer
367                .serialize_field(
368                    "maxSimultaneousTransitions",
369                    &self.m_maxSimultaneousTransitions,
370                )?;
371            serializer.serialize_field("startStateMode", &self.m_startStateMode)?;
372            serializer
373                .serialize_field("selfTransitionMode", &self.m_selfTransitionMode)?;
374            serializer.skip_field("isActive", &self.m_isActive)?;
375            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
376            serializer
377                .serialize_array_field("states", &self.m_states, TypeSize::NonPtr)?;
378            serializer
379                .serialize_field("wildcardTransitions", &self.m_wildcardTransitions)?;
380            serializer.skip_field("stateIdToIndexMap", &self.m_stateIdToIndexMap)?;
381            serializer
382                .skip_array_field(
383                    "activeTransitions",
384                    &self.m_activeTransitions,
385                    TypeSize::NonPtr,
386                )?;
387            serializer
388                .skip_array_field(
389                    "transitionFlags",
390                    &self.m_transitionFlags,
391                    TypeSize::NonPtr,
392                )?;
393            serializer
394                .skip_array_field(
395                    "wildcardTransitionFlags",
396                    &self.m_wildcardTransitionFlags,
397                    TypeSize::NonPtr,
398                )?;
399            serializer
400                .skip_array_field(
401                    "delayedTransitions",
402                    &self.m_delayedTransitions,
403                    TypeSize::NonPtr,
404                )?;
405            serializer.skip_field("timeInState", &self.m_timeInState)?;
406            serializer.skip_field("lastLocalTime", &self.m_lastLocalTime)?;
407            serializer.skip_field("previousStateId", &self.m_previousStateId)?;
408            serializer
409                .skip_field(
410                    "nextStartStateIndexOverride",
411                    &self.m_nextStartStateIndexOverride,
412                )?;
413            serializer
414                .skip_field(
415                    "stateOrTransitionChanged",
416                    &self.m_stateOrTransitionChanged,
417                )?;
418            serializer.skip_field("echoNextUpdate", &self.m_echoNextUpdate)?;
419            serializer
420                .skip_field(
421                    "sCurrentStateIndexAndEntered",
422                    &self.m_sCurrentStateIndexAndEntered,
423                )?;
424            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
425            serializer.end()
426        }
427    }
428};
429#[doc(hidden)]
430#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
431const _: () = {
432    use havok_serde as _serde;
433    #[automatically_derived]
434    impl<'de> _serde::Deserialize<'de> for hkbStateMachine<'de> {
435        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
436        where
437            __D: _serde::Deserializer<'de>,
438        {
439            #[allow(non_camel_case_types)]
440            enum __Field {
441                m_variableBindingSet,
442                m_userData,
443                m_name,
444                m_eventToSendWhenStateOrTransitionChanges,
445                m_startStateChooser,
446                m_startStateId,
447                m_returnToPreviousStateEventId,
448                m_randomTransitionEventId,
449                m_transitionToNextHigherStateEventId,
450                m_transitionToNextLowerStateEventId,
451                m_syncVariableIndex,
452                m_wrapAroundStateId,
453                m_maxSimultaneousTransitions,
454                m_startStateMode,
455                m_selfTransitionMode,
456                m_states,
457                m_wildcardTransitions,
458                __ignore,
459            }
460            struct __FieldVisitor;
461            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
462                type Value = __Field;
463                fn expecting(
464                    &self,
465                    __formatter: &mut core::fmt::Formatter,
466                ) -> core::fmt::Result {
467                    core::fmt::Formatter::write_str(__formatter, "field identifier")
468                }
469                /// Intended for use in XML.
470                #[allow(clippy::match_single_binding)]
471                #[allow(clippy::reversed_empty_ranges)]
472                #[allow(clippy::single_match)]
473                fn visit_key<__E>(
474                    self,
475                    __value: &str,
476                ) -> core::result::Result<Self::Value, __E>
477                where
478                    __E: _serde::de::Error,
479                {
480                    match __value {
481                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
482                        "userData" => Ok(__Field::m_userData),
483                        "name" => Ok(__Field::m_name),
484                        "eventToSendWhenStateOrTransitionChanges" => {
485                            Ok(__Field::m_eventToSendWhenStateOrTransitionChanges)
486                        }
487                        "startStateChooser" => Ok(__Field::m_startStateChooser),
488                        "startStateId" => Ok(__Field::m_startStateId),
489                        "returnToPreviousStateEventId" => {
490                            Ok(__Field::m_returnToPreviousStateEventId)
491                        }
492                        "randomTransitionEventId" => {
493                            Ok(__Field::m_randomTransitionEventId)
494                        }
495                        "transitionToNextHigherStateEventId" => {
496                            Ok(__Field::m_transitionToNextHigherStateEventId)
497                        }
498                        "transitionToNextLowerStateEventId" => {
499                            Ok(__Field::m_transitionToNextLowerStateEventId)
500                        }
501                        "syncVariableIndex" => Ok(__Field::m_syncVariableIndex),
502                        "wrapAroundStateId" => Ok(__Field::m_wrapAroundStateId),
503                        "maxSimultaneousTransitions" => {
504                            Ok(__Field::m_maxSimultaneousTransitions)
505                        }
506                        "startStateMode" => Ok(__Field::m_startStateMode),
507                        "selfTransitionMode" => Ok(__Field::m_selfTransitionMode),
508                        "states" => Ok(__Field::m_states),
509                        "wildcardTransitions" => Ok(__Field::m_wildcardTransitions),
510                        _ => Ok(__Field::__ignore),
511                    }
512                }
513            }
514            impl<'de> _serde::Deserialize<'de> for __Field {
515                #[inline]
516                fn deserialize<__D>(
517                    __deserializer: __D,
518                ) -> core::result::Result<Self, __D::Error>
519                where
520                    __D: _serde::Deserializer<'de>,
521                {
522                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
523                }
524            }
525            struct __hkbStateMachineVisitor<'de> {
526                marker: _serde::__private::PhantomData<hkbStateMachine<'de>>,
527                lifetime: _serde::__private::PhantomData<&'de ()>,
528            }
529            #[allow(clippy::match_single_binding)]
530            #[allow(clippy::reversed_empty_ranges)]
531            #[allow(clippy::single_match)]
532            impl<'de> _serde::de::Visitor<'de> for __hkbStateMachineVisitor<'de> {
533                type Value = hkbStateMachine<'de>;
534                fn expecting(
535                    &self,
536                    __formatter: &mut core::fmt::Formatter,
537                ) -> core::fmt::Result {
538                    core::fmt::Formatter::write_str(
539                        __formatter,
540                        "struct hkbStateMachine",
541                    )
542                }
543                fn visit_struct_for_bytes<__A>(
544                    self,
545                    mut __map: __A,
546                ) -> _serde::__private::Result<Self::Value, __A::Error>
547                where
548                    __A: _serde::de::MapAccess<'de>,
549                {
550                    let __ptr = __A::class_ptr(&mut __map);
551                    let parent = __A::parent_value(&mut __map)?;
552                    let mut m_eventToSendWhenStateOrTransitionChanges: _serde::__private::Option<
553                        hkbEvent,
554                    > = _serde::__private::None;
555                    let mut m_startStateChooser: _serde::__private::Option<Pointer> = _serde::__private::None;
556                    let mut m_startStateId: _serde::__private::Option<i32> = _serde::__private::None;
557                    let mut m_returnToPreviousStateEventId: _serde::__private::Option<
558                        i32,
559                    > = _serde::__private::None;
560                    let mut m_randomTransitionEventId: _serde::__private::Option<i32> = _serde::__private::None;
561                    let mut m_transitionToNextHigherStateEventId: _serde::__private::Option<
562                        i32,
563                    > = _serde::__private::None;
564                    let mut m_transitionToNextLowerStateEventId: _serde::__private::Option<
565                        i32,
566                    > = _serde::__private::None;
567                    let mut m_syncVariableIndex: _serde::__private::Option<i32> = _serde::__private::None;
568                    let mut m_currentStateId: _serde::__private::Option<i32> = _serde::__private::None;
569                    let mut m_wrapAroundStateId: _serde::__private::Option<bool> = _serde::__private::None;
570                    let mut m_maxSimultaneousTransitions: _serde::__private::Option<
571                        i8,
572                    > = _serde::__private::None;
573                    let mut m_startStateMode: _serde::__private::Option<
574                        StartStateMode,
575                    > = _serde::__private::None;
576                    let mut m_selfTransitionMode: _serde::__private::Option<
577                        StateMachineSelfTransitionMode,
578                    > = _serde::__private::None;
579                    let mut m_isActive: _serde::__private::Option<bool> = _serde::__private::None;
580                    let mut m_states: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
581                    let mut m_wildcardTransitions: _serde::__private::Option<Pointer> = _serde::__private::None;
582                    let mut m_stateIdToIndexMap: _serde::__private::Option<Pointer> = _serde::__private::None;
583                    let mut m_activeTransitions: _serde::__private::Option<Vec<()>> = _serde::__private::None;
584                    let mut m_transitionFlags: _serde::__private::Option<Vec<()>> = _serde::__private::None;
585                    let mut m_wildcardTransitionFlags: _serde::__private::Option<
586                        Vec<()>,
587                    > = _serde::__private::None;
588                    let mut m_delayedTransitions: _serde::__private::Option<Vec<()>> = _serde::__private::None;
589                    let mut m_timeInState: _serde::__private::Option<f32> = _serde::__private::None;
590                    let mut m_lastLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
591                    let mut m_previousStateId: _serde::__private::Option<i32> = _serde::__private::None;
592                    let mut m_nextStartStateIndexOverride: _serde::__private::Option<
593                        i32,
594                    > = _serde::__private::None;
595                    let mut m_stateOrTransitionChanged: _serde::__private::Option<
596                        bool,
597                    > = _serde::__private::None;
598                    let mut m_echoNextUpdate: _serde::__private::Option<bool> = _serde::__private::None;
599                    let mut m_sCurrentStateIndexAndEntered: _serde::__private::Option<
600                        u16,
601                    > = _serde::__private::None;
602                    for i in 0..28usize {
603                        match i {
604                            0usize => {
605                                if _serde::__private::Option::is_some(
606                                    &m_eventToSendWhenStateOrTransitionChanges,
607                                ) {
608                                    return _serde::__private::Err(
609                                        <__A::Error as _serde::de::Error>::duplicate_field(
610                                            "eventToSendWhenStateOrTransitionChanges",
611                                        ),
612                                    );
613                                }
614                                m_eventToSendWhenStateOrTransitionChanges = _serde::__private::Some(
615                                    match __A::next_value::<hkbEvent>(&mut __map) {
616                                        _serde::__private::Ok(__val) => __val,
617                                        _serde::__private::Err(__err) => {
618                                            return _serde::__private::Err(__err);
619                                        }
620                                    },
621                                );
622                            }
623                            1usize => {
624                                if _serde::__private::Option::is_some(
625                                    &m_startStateChooser,
626                                ) {
627                                    return _serde::__private::Err(
628                                        <__A::Error as _serde::de::Error>::duplicate_field(
629                                            "startStateChooser",
630                                        ),
631                                    );
632                                }
633                                m_startStateChooser = _serde::__private::Some(
634                                    match __A::next_value::<Pointer>(&mut __map) {
635                                        _serde::__private::Ok(__val) => __val,
636                                        _serde::__private::Err(__err) => {
637                                            return _serde::__private::Err(__err);
638                                        }
639                                    },
640                                );
641                            }
642                            2usize => {
643                                if _serde::__private::Option::is_some(&m_startStateId) {
644                                    return _serde::__private::Err(
645                                        <__A::Error as _serde::de::Error>::duplicate_field(
646                                            "startStateId",
647                                        ),
648                                    );
649                                }
650                                m_startStateId = _serde::__private::Some(
651                                    match __A::next_value::<i32>(&mut __map) {
652                                        _serde::__private::Ok(__val) => __val,
653                                        _serde::__private::Err(__err) => {
654                                            return _serde::__private::Err(__err);
655                                        }
656                                    },
657                                );
658                            }
659                            3usize => {
660                                if _serde::__private::Option::is_some(
661                                    &m_returnToPreviousStateEventId,
662                                ) {
663                                    return _serde::__private::Err(
664                                        <__A::Error as _serde::de::Error>::duplicate_field(
665                                            "returnToPreviousStateEventId",
666                                        ),
667                                    );
668                                }
669                                m_returnToPreviousStateEventId = _serde::__private::Some(
670                                    match __A::next_value::<i32>(&mut __map) {
671                                        _serde::__private::Ok(__val) => __val,
672                                        _serde::__private::Err(__err) => {
673                                            return _serde::__private::Err(__err);
674                                        }
675                                    },
676                                );
677                            }
678                            4usize => {
679                                if _serde::__private::Option::is_some(
680                                    &m_randomTransitionEventId,
681                                ) {
682                                    return _serde::__private::Err(
683                                        <__A::Error as _serde::de::Error>::duplicate_field(
684                                            "randomTransitionEventId",
685                                        ),
686                                    );
687                                }
688                                m_randomTransitionEventId = _serde::__private::Some(
689                                    match __A::next_value::<i32>(&mut __map) {
690                                        _serde::__private::Ok(__val) => __val,
691                                        _serde::__private::Err(__err) => {
692                                            return _serde::__private::Err(__err);
693                                        }
694                                    },
695                                );
696                            }
697                            5usize => {
698                                if _serde::__private::Option::is_some(
699                                    &m_transitionToNextHigherStateEventId,
700                                ) {
701                                    return _serde::__private::Err(
702                                        <__A::Error as _serde::de::Error>::duplicate_field(
703                                            "transitionToNextHigherStateEventId",
704                                        ),
705                                    );
706                                }
707                                m_transitionToNextHigherStateEventId = _serde::__private::Some(
708                                    match __A::next_value::<i32>(&mut __map) {
709                                        _serde::__private::Ok(__val) => __val,
710                                        _serde::__private::Err(__err) => {
711                                            return _serde::__private::Err(__err);
712                                        }
713                                    },
714                                );
715                            }
716                            6usize => {
717                                if _serde::__private::Option::is_some(
718                                    &m_transitionToNextLowerStateEventId,
719                                ) {
720                                    return _serde::__private::Err(
721                                        <__A::Error as _serde::de::Error>::duplicate_field(
722                                            "transitionToNextLowerStateEventId",
723                                        ),
724                                    );
725                                }
726                                m_transitionToNextLowerStateEventId = _serde::__private::Some(
727                                    match __A::next_value::<i32>(&mut __map) {
728                                        _serde::__private::Ok(__val) => __val,
729                                        _serde::__private::Err(__err) => {
730                                            return _serde::__private::Err(__err);
731                                        }
732                                    },
733                                );
734                            }
735                            7usize => {
736                                if _serde::__private::Option::is_some(
737                                    &m_syncVariableIndex,
738                                ) {
739                                    return _serde::__private::Err(
740                                        <__A::Error as _serde::de::Error>::duplicate_field(
741                                            "syncVariableIndex",
742                                        ),
743                                    );
744                                }
745                                m_syncVariableIndex = _serde::__private::Some(
746                                    match __A::next_value::<i32>(&mut __map) {
747                                        _serde::__private::Ok(__val) => __val,
748                                        _serde::__private::Err(__err) => {
749                                            return _serde::__private::Err(__err);
750                                        }
751                                    },
752                                );
753                            }
754                            8usize => {
755                                if _serde::__private::Option::is_some(&m_currentStateId) {
756                                    return _serde::__private::Err(
757                                        <__A::Error as _serde::de::Error>::duplicate_field(
758                                            "currentStateId",
759                                        ),
760                                    );
761                                }
762                                m_currentStateId = _serde::__private::Some(
763                                    match __A::next_value::<i32>(&mut __map) {
764                                        _serde::__private::Ok(__val) => __val,
765                                        _serde::__private::Err(__err) => {
766                                            return _serde::__private::Err(__err);
767                                        }
768                                    },
769                                );
770                            }
771                            9usize => {
772                                if _serde::__private::Option::is_some(
773                                    &m_wrapAroundStateId,
774                                ) {
775                                    return _serde::__private::Err(
776                                        <__A::Error as _serde::de::Error>::duplicate_field(
777                                            "wrapAroundStateId",
778                                        ),
779                                    );
780                                }
781                                m_wrapAroundStateId = _serde::__private::Some(
782                                    match __A::next_value::<bool>(&mut __map) {
783                                        _serde::__private::Ok(__val) => __val,
784                                        _serde::__private::Err(__err) => {
785                                            return _serde::__private::Err(__err);
786                                        }
787                                    },
788                                );
789                            }
790                            10usize => {
791                                if _serde::__private::Option::is_some(
792                                    &m_maxSimultaneousTransitions,
793                                ) {
794                                    return _serde::__private::Err(
795                                        <__A::Error as _serde::de::Error>::duplicate_field(
796                                            "maxSimultaneousTransitions",
797                                        ),
798                                    );
799                                }
800                                m_maxSimultaneousTransitions = _serde::__private::Some(
801                                    match __A::next_value::<i8>(&mut __map) {
802                                        _serde::__private::Ok(__val) => __val,
803                                        _serde::__private::Err(__err) => {
804                                            return _serde::__private::Err(__err);
805                                        }
806                                    },
807                                );
808                            }
809                            11usize => {
810                                if _serde::__private::Option::is_some(&m_startStateMode) {
811                                    return _serde::__private::Err(
812                                        <__A::Error as _serde::de::Error>::duplicate_field(
813                                            "startStateMode",
814                                        ),
815                                    );
816                                }
817                                m_startStateMode = _serde::__private::Some(
818                                    match __A::next_value::<StartStateMode>(&mut __map) {
819                                        _serde::__private::Ok(__val) => __val,
820                                        _serde::__private::Err(__err) => {
821                                            return _serde::__private::Err(__err);
822                                        }
823                                    },
824                                );
825                            }
826                            12usize => {
827                                if _serde::__private::Option::is_some(
828                                    &m_selfTransitionMode,
829                                ) {
830                                    return _serde::__private::Err(
831                                        <__A::Error as _serde::de::Error>::duplicate_field(
832                                            "selfTransitionMode",
833                                        ),
834                                    );
835                                }
836                                m_selfTransitionMode = _serde::__private::Some(
837                                    match __A::next_value::<
838                                        StateMachineSelfTransitionMode,
839                                    >(&mut __map) {
840                                        _serde::__private::Ok(__val) => __val,
841                                        _serde::__private::Err(__err) => {
842                                            return _serde::__private::Err(__err);
843                                        }
844                                    },
845                                );
846                            }
847                            13usize => {
848                                if _serde::__private::Option::is_some(&m_isActive) {
849                                    return _serde::__private::Err(
850                                        <__A::Error as _serde::de::Error>::duplicate_field(
851                                            "isActive",
852                                        ),
853                                    );
854                                }
855                                m_isActive = _serde::__private::Some(
856                                    match __A::next_value::<bool>(&mut __map) {
857                                        _serde::__private::Ok(__val) => __val,
858                                        _serde::__private::Err(__err) => {
859                                            return _serde::__private::Err(__err);
860                                        }
861                                    },
862                                );
863                            }
864                            14usize => {
865                                if _serde::__private::Option::is_some(&m_states) {
866                                    return _serde::__private::Err(
867                                        <__A::Error as _serde::de::Error>::duplicate_field("states"),
868                                    );
869                                }
870                                __A::pad(&mut __map, 3usize, 7usize)?;
871                                m_states = _serde::__private::Some(
872                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
873                                        _serde::__private::Ok(__val) => __val,
874                                        _serde::__private::Err(__err) => {
875                                            return _serde::__private::Err(__err);
876                                        }
877                                    },
878                                );
879                            }
880                            15usize => {
881                                if _serde::__private::Option::is_some(
882                                    &m_wildcardTransitions,
883                                ) {
884                                    return _serde::__private::Err(
885                                        <__A::Error as _serde::de::Error>::duplicate_field(
886                                            "wildcardTransitions",
887                                        ),
888                                    );
889                                }
890                                m_wildcardTransitions = _serde::__private::Some(
891                                    match __A::next_value::<Pointer>(&mut __map) {
892                                        _serde::__private::Ok(__val) => __val,
893                                        _serde::__private::Err(__err) => {
894                                            return _serde::__private::Err(__err);
895                                        }
896                                    },
897                                );
898                            }
899                            16usize => {
900                                if _serde::__private::Option::is_some(
901                                    &m_stateIdToIndexMap,
902                                ) {
903                                    return _serde::__private::Err(
904                                        <__A::Error as _serde::de::Error>::duplicate_field(
905                                            "stateIdToIndexMap",
906                                        ),
907                                    );
908                                }
909                                m_stateIdToIndexMap = _serde::__private::Some(
910                                    match __A::next_value::<Pointer>(&mut __map) {
911                                        _serde::__private::Ok(__val) => __val,
912                                        _serde::__private::Err(__err) => {
913                                            return _serde::__private::Err(__err);
914                                        }
915                                    },
916                                );
917                            }
918                            17usize => {
919                                if _serde::__private::Option::is_some(
920                                    &m_activeTransitions,
921                                ) {
922                                    return _serde::__private::Err(
923                                        <__A::Error as _serde::de::Error>::duplicate_field(
924                                            "activeTransitions",
925                                        ),
926                                    );
927                                }
928                                m_activeTransitions = _serde::__private::Some(
929                                    match __A::next_value::<Vec<()>>(&mut __map) {
930                                        _serde::__private::Ok(__val) => __val,
931                                        _serde::__private::Err(__err) => {
932                                            return _serde::__private::Err(__err);
933                                        }
934                                    },
935                                );
936                            }
937                            18usize => {
938                                if _serde::__private::Option::is_some(&m_transitionFlags) {
939                                    return _serde::__private::Err(
940                                        <__A::Error as _serde::de::Error>::duplicate_field(
941                                            "transitionFlags",
942                                        ),
943                                    );
944                                }
945                                m_transitionFlags = _serde::__private::Some(
946                                    match __A::next_value::<Vec<()>>(&mut __map) {
947                                        _serde::__private::Ok(__val) => __val,
948                                        _serde::__private::Err(__err) => {
949                                            return _serde::__private::Err(__err);
950                                        }
951                                    },
952                                );
953                            }
954                            19usize => {
955                                if _serde::__private::Option::is_some(
956                                    &m_wildcardTransitionFlags,
957                                ) {
958                                    return _serde::__private::Err(
959                                        <__A::Error as _serde::de::Error>::duplicate_field(
960                                            "wildcardTransitionFlags",
961                                        ),
962                                    );
963                                }
964                                m_wildcardTransitionFlags = _serde::__private::Some(
965                                    match __A::next_value::<Vec<()>>(&mut __map) {
966                                        _serde::__private::Ok(__val) => __val,
967                                        _serde::__private::Err(__err) => {
968                                            return _serde::__private::Err(__err);
969                                        }
970                                    },
971                                );
972                            }
973                            20usize => {
974                                if _serde::__private::Option::is_some(
975                                    &m_delayedTransitions,
976                                ) {
977                                    return _serde::__private::Err(
978                                        <__A::Error as _serde::de::Error>::duplicate_field(
979                                            "delayedTransitions",
980                                        ),
981                                    );
982                                }
983                                m_delayedTransitions = _serde::__private::Some(
984                                    match __A::next_value::<Vec<()>>(&mut __map) {
985                                        _serde::__private::Ok(__val) => __val,
986                                        _serde::__private::Err(__err) => {
987                                            return _serde::__private::Err(__err);
988                                        }
989                                    },
990                                );
991                            }
992                            21usize => {
993                                if _serde::__private::Option::is_some(&m_timeInState) {
994                                    return _serde::__private::Err(
995                                        <__A::Error as _serde::de::Error>::duplicate_field(
996                                            "timeInState",
997                                        ),
998                                    );
999                                }
1000                                m_timeInState = _serde::__private::Some(
1001                                    match __A::next_value::<f32>(&mut __map) {
1002                                        _serde::__private::Ok(__val) => __val,
1003                                        _serde::__private::Err(__err) => {
1004                                            return _serde::__private::Err(__err);
1005                                        }
1006                                    },
1007                                );
1008                            }
1009                            22usize => {
1010                                if _serde::__private::Option::is_some(&m_lastLocalTime) {
1011                                    return _serde::__private::Err(
1012                                        <__A::Error as _serde::de::Error>::duplicate_field(
1013                                            "lastLocalTime",
1014                                        ),
1015                                    );
1016                                }
1017                                m_lastLocalTime = _serde::__private::Some(
1018                                    match __A::next_value::<f32>(&mut __map) {
1019                                        _serde::__private::Ok(__val) => __val,
1020                                        _serde::__private::Err(__err) => {
1021                                            return _serde::__private::Err(__err);
1022                                        }
1023                                    },
1024                                );
1025                            }
1026                            23usize => {
1027                                if _serde::__private::Option::is_some(&m_previousStateId) {
1028                                    return _serde::__private::Err(
1029                                        <__A::Error as _serde::de::Error>::duplicate_field(
1030                                            "previousStateId",
1031                                        ),
1032                                    );
1033                                }
1034                                m_previousStateId = _serde::__private::Some(
1035                                    match __A::next_value::<i32>(&mut __map) {
1036                                        _serde::__private::Ok(__val) => __val,
1037                                        _serde::__private::Err(__err) => {
1038                                            return _serde::__private::Err(__err);
1039                                        }
1040                                    },
1041                                );
1042                            }
1043                            24usize => {
1044                                if _serde::__private::Option::is_some(
1045                                    &m_nextStartStateIndexOverride,
1046                                ) {
1047                                    return _serde::__private::Err(
1048                                        <__A::Error as _serde::de::Error>::duplicate_field(
1049                                            "nextStartStateIndexOverride",
1050                                        ),
1051                                    );
1052                                }
1053                                m_nextStartStateIndexOverride = _serde::__private::Some(
1054                                    match __A::next_value::<i32>(&mut __map) {
1055                                        _serde::__private::Ok(__val) => __val,
1056                                        _serde::__private::Err(__err) => {
1057                                            return _serde::__private::Err(__err);
1058                                        }
1059                                    },
1060                                );
1061                            }
1062                            25usize => {
1063                                if _serde::__private::Option::is_some(
1064                                    &m_stateOrTransitionChanged,
1065                                ) {
1066                                    return _serde::__private::Err(
1067                                        <__A::Error as _serde::de::Error>::duplicate_field(
1068                                            "stateOrTransitionChanged",
1069                                        ),
1070                                    );
1071                                }
1072                                m_stateOrTransitionChanged = _serde::__private::Some(
1073                                    match __A::next_value::<bool>(&mut __map) {
1074                                        _serde::__private::Ok(__val) => __val,
1075                                        _serde::__private::Err(__err) => {
1076                                            return _serde::__private::Err(__err);
1077                                        }
1078                                    },
1079                                );
1080                            }
1081                            26usize => {
1082                                if _serde::__private::Option::is_some(&m_echoNextUpdate) {
1083                                    return _serde::__private::Err(
1084                                        <__A::Error as _serde::de::Error>::duplicate_field(
1085                                            "echoNextUpdate",
1086                                        ),
1087                                    );
1088                                }
1089                                m_echoNextUpdate = _serde::__private::Some(
1090                                    match __A::next_value::<bool>(&mut __map) {
1091                                        _serde::__private::Ok(__val) => __val,
1092                                        _serde::__private::Err(__err) => {
1093                                            return _serde::__private::Err(__err);
1094                                        }
1095                                    },
1096                                );
1097                            }
1098                            27usize => {
1099                                if _serde::__private::Option::is_some(
1100                                    &m_sCurrentStateIndexAndEntered,
1101                                ) {
1102                                    return _serde::__private::Err(
1103                                        <__A::Error as _serde::de::Error>::duplicate_field(
1104                                            "sCurrentStateIndexAndEntered",
1105                                        ),
1106                                    );
1107                                }
1108                                m_sCurrentStateIndexAndEntered = _serde::__private::Some(
1109                                    match __A::next_value::<u16>(&mut __map) {
1110                                        _serde::__private::Ok(__val) => __val,
1111                                        _serde::__private::Err(__err) => {
1112                                            return _serde::__private::Err(__err);
1113                                        }
1114                                    },
1115                                );
1116                            }
1117                            _ => {}
1118                        }
1119                    }
1120                    __A::pad(&mut __map, 0usize, 4usize)?;
1121                    let m_eventToSendWhenStateOrTransitionChanges = match m_eventToSendWhenStateOrTransitionChanges {
1122                        _serde::__private::Some(__field) => __field,
1123                        _serde::__private::None => {
1124                            return _serde::__private::Err(
1125                                <__A::Error as _serde::de::Error>::missing_field(
1126                                    "eventToSendWhenStateOrTransitionChanges",
1127                                ),
1128                            );
1129                        }
1130                    };
1131                    let m_startStateChooser = match m_startStateChooser {
1132                        _serde::__private::Some(__field) => __field,
1133                        _serde::__private::None => {
1134                            return _serde::__private::Err(
1135                                <__A::Error as _serde::de::Error>::missing_field(
1136                                    "startStateChooser",
1137                                ),
1138                            );
1139                        }
1140                    };
1141                    let m_startStateId = match m_startStateId {
1142                        _serde::__private::Some(__field) => __field,
1143                        _serde::__private::None => {
1144                            return _serde::__private::Err(
1145                                <__A::Error as _serde::de::Error>::missing_field(
1146                                    "startStateId",
1147                                ),
1148                            );
1149                        }
1150                    };
1151                    let m_returnToPreviousStateEventId = match m_returnToPreviousStateEventId {
1152                        _serde::__private::Some(__field) => __field,
1153                        _serde::__private::None => {
1154                            return _serde::__private::Err(
1155                                <__A::Error as _serde::de::Error>::missing_field(
1156                                    "returnToPreviousStateEventId",
1157                                ),
1158                            );
1159                        }
1160                    };
1161                    let m_randomTransitionEventId = match m_randomTransitionEventId {
1162                        _serde::__private::Some(__field) => __field,
1163                        _serde::__private::None => {
1164                            return _serde::__private::Err(
1165                                <__A::Error as _serde::de::Error>::missing_field(
1166                                    "randomTransitionEventId",
1167                                ),
1168                            );
1169                        }
1170                    };
1171                    let m_transitionToNextHigherStateEventId = match m_transitionToNextHigherStateEventId {
1172                        _serde::__private::Some(__field) => __field,
1173                        _serde::__private::None => {
1174                            return _serde::__private::Err(
1175                                <__A::Error as _serde::de::Error>::missing_field(
1176                                    "transitionToNextHigherStateEventId",
1177                                ),
1178                            );
1179                        }
1180                    };
1181                    let m_transitionToNextLowerStateEventId = match m_transitionToNextLowerStateEventId {
1182                        _serde::__private::Some(__field) => __field,
1183                        _serde::__private::None => {
1184                            return _serde::__private::Err(
1185                                <__A::Error as _serde::de::Error>::missing_field(
1186                                    "transitionToNextLowerStateEventId",
1187                                ),
1188                            );
1189                        }
1190                    };
1191                    let m_syncVariableIndex = match m_syncVariableIndex {
1192                        _serde::__private::Some(__field) => __field,
1193                        _serde::__private::None => {
1194                            return _serde::__private::Err(
1195                                <__A::Error as _serde::de::Error>::missing_field(
1196                                    "syncVariableIndex",
1197                                ),
1198                            );
1199                        }
1200                    };
1201                    let m_currentStateId = match m_currentStateId {
1202                        _serde::__private::Some(__field) => __field,
1203                        _serde::__private::None => {
1204                            return _serde::__private::Err(
1205                                <__A::Error as _serde::de::Error>::missing_field(
1206                                    "currentStateId",
1207                                ),
1208                            );
1209                        }
1210                    };
1211                    let m_wrapAroundStateId = match m_wrapAroundStateId {
1212                        _serde::__private::Some(__field) => __field,
1213                        _serde::__private::None => {
1214                            return _serde::__private::Err(
1215                                <__A::Error as _serde::de::Error>::missing_field(
1216                                    "wrapAroundStateId",
1217                                ),
1218                            );
1219                        }
1220                    };
1221                    let m_maxSimultaneousTransitions = match m_maxSimultaneousTransitions {
1222                        _serde::__private::Some(__field) => __field,
1223                        _serde::__private::None => {
1224                            return _serde::__private::Err(
1225                                <__A::Error as _serde::de::Error>::missing_field(
1226                                    "maxSimultaneousTransitions",
1227                                ),
1228                            );
1229                        }
1230                    };
1231                    let m_startStateMode = match m_startStateMode {
1232                        _serde::__private::Some(__field) => __field,
1233                        _serde::__private::None => {
1234                            return _serde::__private::Err(
1235                                <__A::Error as _serde::de::Error>::missing_field(
1236                                    "startStateMode",
1237                                ),
1238                            );
1239                        }
1240                    };
1241                    let m_selfTransitionMode = match m_selfTransitionMode {
1242                        _serde::__private::Some(__field) => __field,
1243                        _serde::__private::None => {
1244                            return _serde::__private::Err(
1245                                <__A::Error as _serde::de::Error>::missing_field(
1246                                    "selfTransitionMode",
1247                                ),
1248                            );
1249                        }
1250                    };
1251                    let m_isActive = match m_isActive {
1252                        _serde::__private::Some(__field) => __field,
1253                        _serde::__private::None => {
1254                            return _serde::__private::Err(
1255                                <__A::Error as _serde::de::Error>::missing_field("isActive"),
1256                            );
1257                        }
1258                    };
1259                    let m_states = match m_states {
1260                        _serde::__private::Some(__field) => __field,
1261                        _serde::__private::None => {
1262                            return _serde::__private::Err(
1263                                <__A::Error as _serde::de::Error>::missing_field("states"),
1264                            );
1265                        }
1266                    };
1267                    let m_wildcardTransitions = match m_wildcardTransitions {
1268                        _serde::__private::Some(__field) => __field,
1269                        _serde::__private::None => {
1270                            return _serde::__private::Err(
1271                                <__A::Error as _serde::de::Error>::missing_field(
1272                                    "wildcardTransitions",
1273                                ),
1274                            );
1275                        }
1276                    };
1277                    let m_stateIdToIndexMap = match m_stateIdToIndexMap {
1278                        _serde::__private::Some(__field) => __field,
1279                        _serde::__private::None => {
1280                            return _serde::__private::Err(
1281                                <__A::Error as _serde::de::Error>::missing_field(
1282                                    "stateIdToIndexMap",
1283                                ),
1284                            );
1285                        }
1286                    };
1287                    let m_activeTransitions = match m_activeTransitions {
1288                        _serde::__private::Some(__field) => __field,
1289                        _serde::__private::None => {
1290                            return _serde::__private::Err(
1291                                <__A::Error as _serde::de::Error>::missing_field(
1292                                    "activeTransitions",
1293                                ),
1294                            );
1295                        }
1296                    };
1297                    let m_transitionFlags = match m_transitionFlags {
1298                        _serde::__private::Some(__field) => __field,
1299                        _serde::__private::None => {
1300                            return _serde::__private::Err(
1301                                <__A::Error as _serde::de::Error>::missing_field(
1302                                    "transitionFlags",
1303                                ),
1304                            );
1305                        }
1306                    };
1307                    let m_wildcardTransitionFlags = match m_wildcardTransitionFlags {
1308                        _serde::__private::Some(__field) => __field,
1309                        _serde::__private::None => {
1310                            return _serde::__private::Err(
1311                                <__A::Error as _serde::de::Error>::missing_field(
1312                                    "wildcardTransitionFlags",
1313                                ),
1314                            );
1315                        }
1316                    };
1317                    let m_delayedTransitions = match m_delayedTransitions {
1318                        _serde::__private::Some(__field) => __field,
1319                        _serde::__private::None => {
1320                            return _serde::__private::Err(
1321                                <__A::Error as _serde::de::Error>::missing_field(
1322                                    "delayedTransitions",
1323                                ),
1324                            );
1325                        }
1326                    };
1327                    let m_timeInState = match m_timeInState {
1328                        _serde::__private::Some(__field) => __field,
1329                        _serde::__private::None => {
1330                            return _serde::__private::Err(
1331                                <__A::Error as _serde::de::Error>::missing_field(
1332                                    "timeInState",
1333                                ),
1334                            );
1335                        }
1336                    };
1337                    let m_lastLocalTime = match m_lastLocalTime {
1338                        _serde::__private::Some(__field) => __field,
1339                        _serde::__private::None => {
1340                            return _serde::__private::Err(
1341                                <__A::Error as _serde::de::Error>::missing_field(
1342                                    "lastLocalTime",
1343                                ),
1344                            );
1345                        }
1346                    };
1347                    let m_previousStateId = match m_previousStateId {
1348                        _serde::__private::Some(__field) => __field,
1349                        _serde::__private::None => {
1350                            return _serde::__private::Err(
1351                                <__A::Error as _serde::de::Error>::missing_field(
1352                                    "previousStateId",
1353                                ),
1354                            );
1355                        }
1356                    };
1357                    let m_nextStartStateIndexOverride = match m_nextStartStateIndexOverride {
1358                        _serde::__private::Some(__field) => __field,
1359                        _serde::__private::None => {
1360                            return _serde::__private::Err(
1361                                <__A::Error as _serde::de::Error>::missing_field(
1362                                    "nextStartStateIndexOverride",
1363                                ),
1364                            );
1365                        }
1366                    };
1367                    let m_stateOrTransitionChanged = match m_stateOrTransitionChanged {
1368                        _serde::__private::Some(__field) => __field,
1369                        _serde::__private::None => {
1370                            return _serde::__private::Err(
1371                                <__A::Error as _serde::de::Error>::missing_field(
1372                                    "stateOrTransitionChanged",
1373                                ),
1374                            );
1375                        }
1376                    };
1377                    let m_echoNextUpdate = match m_echoNextUpdate {
1378                        _serde::__private::Some(__field) => __field,
1379                        _serde::__private::None => {
1380                            return _serde::__private::Err(
1381                                <__A::Error as _serde::de::Error>::missing_field(
1382                                    "echoNextUpdate",
1383                                ),
1384                            );
1385                        }
1386                    };
1387                    let m_sCurrentStateIndexAndEntered = match m_sCurrentStateIndexAndEntered {
1388                        _serde::__private::Some(__field) => __field,
1389                        _serde::__private::None => {
1390                            return _serde::__private::Err(
1391                                <__A::Error as _serde::de::Error>::missing_field(
1392                                    "sCurrentStateIndexAndEntered",
1393                                ),
1394                            );
1395                        }
1396                    };
1397                    _serde::__private::Ok(hkbStateMachine {
1398                        __ptr,
1399                        parent,
1400                        m_eventToSendWhenStateOrTransitionChanges,
1401                        m_startStateChooser,
1402                        m_startStateId,
1403                        m_returnToPreviousStateEventId,
1404                        m_randomTransitionEventId,
1405                        m_transitionToNextHigherStateEventId,
1406                        m_transitionToNextLowerStateEventId,
1407                        m_syncVariableIndex,
1408                        m_currentStateId,
1409                        m_wrapAroundStateId,
1410                        m_maxSimultaneousTransitions,
1411                        m_startStateMode,
1412                        m_selfTransitionMode,
1413                        m_isActive,
1414                        m_states,
1415                        m_wildcardTransitions,
1416                        m_stateIdToIndexMap,
1417                        m_activeTransitions,
1418                        m_transitionFlags,
1419                        m_wildcardTransitionFlags,
1420                        m_delayedTransitions,
1421                        m_timeInState,
1422                        m_lastLocalTime,
1423                        m_previousStateId,
1424                        m_nextStartStateIndexOverride,
1425                        m_stateOrTransitionChanged,
1426                        m_echoNextUpdate,
1427                        m_sCurrentStateIndexAndEntered,
1428                    })
1429                }
1430                #[allow(clippy::manual_unwrap_or_default)]
1431                fn visit_struct<__A>(
1432                    self,
1433                    mut __map: __A,
1434                ) -> _serde::__private::Result<Self::Value, __A::Error>
1435                where
1436                    __A: _serde::de::MapAccess<'de>,
1437                {
1438                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1439                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1440                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1441                    let mut m_eventToSendWhenStateOrTransitionChanges: _serde::__private::Option<
1442                        hkbEvent,
1443                    > = _serde::__private::None;
1444                    let mut m_startStateChooser: _serde::__private::Option<Pointer> = _serde::__private::None;
1445                    let mut m_startStateId: _serde::__private::Option<i32> = _serde::__private::None;
1446                    let mut m_returnToPreviousStateEventId: _serde::__private::Option<
1447                        i32,
1448                    > = _serde::__private::None;
1449                    let mut m_randomTransitionEventId: _serde::__private::Option<i32> = _serde::__private::None;
1450                    let mut m_transitionToNextHigherStateEventId: _serde::__private::Option<
1451                        i32,
1452                    > = _serde::__private::None;
1453                    let mut m_transitionToNextLowerStateEventId: _serde::__private::Option<
1454                        i32,
1455                    > = _serde::__private::None;
1456                    let mut m_syncVariableIndex: _serde::__private::Option<i32> = _serde::__private::None;
1457                    let mut m_wrapAroundStateId: _serde::__private::Option<bool> = _serde::__private::None;
1458                    let mut m_maxSimultaneousTransitions: _serde::__private::Option<
1459                        i8,
1460                    > = _serde::__private::None;
1461                    let mut m_startStateMode: _serde::__private::Option<
1462                        StartStateMode,
1463                    > = _serde::__private::None;
1464                    let mut m_selfTransitionMode: _serde::__private::Option<
1465                        StateMachineSelfTransitionMode,
1466                    > = _serde::__private::None;
1467                    let mut m_states: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
1468                    let mut m_wildcardTransitions: _serde::__private::Option<Pointer> = _serde::__private::None;
1469                    while let _serde::__private::Some(__key) = {
1470                        __A::next_key::<__Field>(&mut __map)?
1471                    } {
1472                        match __key {
1473                            __Field::m_variableBindingSet => {
1474                                #[cfg(
1475                                    any(feature = "strict", feature = "ignore_duplicates")
1476                                )]
1477                                if _serde::__private::Option::is_some(
1478                                    &m_variableBindingSet,
1479                                ) {
1480                                    #[cfg(feature = "ignore_duplicates")]
1481                                    {
1482                                        __A::skip_value(&mut __map)?;
1483                                        continue;
1484                                    }
1485                                    #[cfg(feature = "strict")]
1486                                    return _serde::__private::Err(
1487                                        <__A::Error as _serde::de::Error>::duplicate_field(
1488                                            "variableBindingSet",
1489                                        ),
1490                                    );
1491                                }
1492                                m_variableBindingSet = _serde::__private::Some(
1493                                    match __A::next_value::<Pointer>(&mut __map) {
1494                                        _serde::__private::Ok(__val) => __val,
1495                                        _serde::__private::Err(__err) => {
1496                                            return _serde::__private::Err(__err);
1497                                        }
1498                                    },
1499                                );
1500                            }
1501                            __Field::m_userData => {
1502                                #[cfg(
1503                                    any(feature = "strict", feature = "ignore_duplicates")
1504                                )]
1505                                if _serde::__private::Option::is_some(&m_userData) {
1506                                    #[cfg(feature = "ignore_duplicates")]
1507                                    {
1508                                        __A::skip_value(&mut __map)?;
1509                                        continue;
1510                                    }
1511                                    #[cfg(feature = "strict")]
1512                                    return _serde::__private::Err(
1513                                        <__A::Error as _serde::de::Error>::duplicate_field(
1514                                            "userData",
1515                                        ),
1516                                    );
1517                                }
1518                                m_userData = _serde::__private::Some(
1519                                    match __A::next_value::<Ulong>(&mut __map) {
1520                                        _serde::__private::Ok(__val) => __val,
1521                                        _serde::__private::Err(__err) => {
1522                                            return _serde::__private::Err(__err);
1523                                        }
1524                                    },
1525                                );
1526                            }
1527                            __Field::m_name => {
1528                                #[cfg(
1529                                    any(feature = "strict", feature = "ignore_duplicates")
1530                                )]
1531                                if _serde::__private::Option::is_some(&m_name) {
1532                                    #[cfg(feature = "ignore_duplicates")]
1533                                    {
1534                                        __A::skip_value(&mut __map)?;
1535                                        continue;
1536                                    }
1537                                    #[cfg(feature = "strict")]
1538                                    return _serde::__private::Err(
1539                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
1540                                    );
1541                                }
1542                                m_name = _serde::__private::Some(
1543                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
1544                                        _serde::__private::Ok(__val) => __val,
1545                                        _serde::__private::Err(__err) => {
1546                                            return _serde::__private::Err(__err);
1547                                        }
1548                                    },
1549                                );
1550                            }
1551                            __Field::m_eventToSendWhenStateOrTransitionChanges => {
1552                                #[cfg(
1553                                    any(feature = "strict", feature = "ignore_duplicates")
1554                                )]
1555                                if _serde::__private::Option::is_some(
1556                                    &m_eventToSendWhenStateOrTransitionChanges,
1557                                ) {
1558                                    #[cfg(feature = "ignore_duplicates")]
1559                                    {
1560                                        __A::skip_value(&mut __map)?;
1561                                        continue;
1562                                    }
1563                                    #[cfg(feature = "strict")]
1564                                    return _serde::__private::Err(
1565                                        <__A::Error as _serde::de::Error>::duplicate_field(
1566                                            "eventToSendWhenStateOrTransitionChanges",
1567                                        ),
1568                                    );
1569                                }
1570                                m_eventToSendWhenStateOrTransitionChanges = _serde::__private::Some(
1571                                    match __A::next_value::<hkbEvent>(&mut __map) {
1572                                        _serde::__private::Ok(__val) => __val,
1573                                        _serde::__private::Err(__err) => {
1574                                            return _serde::__private::Err(__err);
1575                                        }
1576                                    },
1577                                );
1578                            }
1579                            __Field::m_startStateChooser => {
1580                                #[cfg(
1581                                    any(feature = "strict", feature = "ignore_duplicates")
1582                                )]
1583                                if _serde::__private::Option::is_some(
1584                                    &m_startStateChooser,
1585                                ) {
1586                                    #[cfg(feature = "ignore_duplicates")]
1587                                    {
1588                                        __A::skip_value(&mut __map)?;
1589                                        continue;
1590                                    }
1591                                    #[cfg(feature = "strict")]
1592                                    return _serde::__private::Err(
1593                                        <__A::Error as _serde::de::Error>::duplicate_field(
1594                                            "startStateChooser",
1595                                        ),
1596                                    );
1597                                }
1598                                m_startStateChooser = _serde::__private::Some(
1599                                    match __A::next_value::<Pointer>(&mut __map) {
1600                                        _serde::__private::Ok(__val) => __val,
1601                                        _serde::__private::Err(__err) => {
1602                                            return _serde::__private::Err(__err);
1603                                        }
1604                                    },
1605                                );
1606                            }
1607                            __Field::m_startStateId => {
1608                                #[cfg(
1609                                    any(feature = "strict", feature = "ignore_duplicates")
1610                                )]
1611                                if _serde::__private::Option::is_some(&m_startStateId) {
1612                                    #[cfg(feature = "ignore_duplicates")]
1613                                    {
1614                                        __A::skip_value(&mut __map)?;
1615                                        continue;
1616                                    }
1617                                    #[cfg(feature = "strict")]
1618                                    return _serde::__private::Err(
1619                                        <__A::Error as _serde::de::Error>::duplicate_field(
1620                                            "startStateId",
1621                                        ),
1622                                    );
1623                                }
1624                                m_startStateId = _serde::__private::Some(
1625                                    match __A::next_value::<i32>(&mut __map) {
1626                                        _serde::__private::Ok(__val) => __val,
1627                                        _serde::__private::Err(__err) => {
1628                                            return _serde::__private::Err(__err);
1629                                        }
1630                                    },
1631                                );
1632                            }
1633                            __Field::m_returnToPreviousStateEventId => {
1634                                #[cfg(
1635                                    any(feature = "strict", feature = "ignore_duplicates")
1636                                )]
1637                                if _serde::__private::Option::is_some(
1638                                    &m_returnToPreviousStateEventId,
1639                                ) {
1640                                    #[cfg(feature = "ignore_duplicates")]
1641                                    {
1642                                        __A::skip_value(&mut __map)?;
1643                                        continue;
1644                                    }
1645                                    #[cfg(feature = "strict")]
1646                                    return _serde::__private::Err(
1647                                        <__A::Error as _serde::de::Error>::duplicate_field(
1648                                            "returnToPreviousStateEventId",
1649                                        ),
1650                                    );
1651                                }
1652                                m_returnToPreviousStateEventId = _serde::__private::Some(
1653                                    match __A::next_value::<i32>(&mut __map) {
1654                                        _serde::__private::Ok(__val) => __val,
1655                                        _serde::__private::Err(__err) => {
1656                                            return _serde::__private::Err(__err);
1657                                        }
1658                                    },
1659                                );
1660                            }
1661                            __Field::m_randomTransitionEventId => {
1662                                #[cfg(
1663                                    any(feature = "strict", feature = "ignore_duplicates")
1664                                )]
1665                                if _serde::__private::Option::is_some(
1666                                    &m_randomTransitionEventId,
1667                                ) {
1668                                    #[cfg(feature = "ignore_duplicates")]
1669                                    {
1670                                        __A::skip_value(&mut __map)?;
1671                                        continue;
1672                                    }
1673                                    #[cfg(feature = "strict")]
1674                                    return _serde::__private::Err(
1675                                        <__A::Error as _serde::de::Error>::duplicate_field(
1676                                            "randomTransitionEventId",
1677                                        ),
1678                                    );
1679                                }
1680                                m_randomTransitionEventId = _serde::__private::Some(
1681                                    match __A::next_value::<i32>(&mut __map) {
1682                                        _serde::__private::Ok(__val) => __val,
1683                                        _serde::__private::Err(__err) => {
1684                                            return _serde::__private::Err(__err);
1685                                        }
1686                                    },
1687                                );
1688                            }
1689                            __Field::m_transitionToNextHigherStateEventId => {
1690                                #[cfg(
1691                                    any(feature = "strict", feature = "ignore_duplicates")
1692                                )]
1693                                if _serde::__private::Option::is_some(
1694                                    &m_transitionToNextHigherStateEventId,
1695                                ) {
1696                                    #[cfg(feature = "ignore_duplicates")]
1697                                    {
1698                                        __A::skip_value(&mut __map)?;
1699                                        continue;
1700                                    }
1701                                    #[cfg(feature = "strict")]
1702                                    return _serde::__private::Err(
1703                                        <__A::Error as _serde::de::Error>::duplicate_field(
1704                                            "transitionToNextHigherStateEventId",
1705                                        ),
1706                                    );
1707                                }
1708                                m_transitionToNextHigherStateEventId = _serde::__private::Some(
1709                                    match __A::next_value::<i32>(&mut __map) {
1710                                        _serde::__private::Ok(__val) => __val,
1711                                        _serde::__private::Err(__err) => {
1712                                            return _serde::__private::Err(__err);
1713                                        }
1714                                    },
1715                                );
1716                            }
1717                            __Field::m_transitionToNextLowerStateEventId => {
1718                                #[cfg(
1719                                    any(feature = "strict", feature = "ignore_duplicates")
1720                                )]
1721                                if _serde::__private::Option::is_some(
1722                                    &m_transitionToNextLowerStateEventId,
1723                                ) {
1724                                    #[cfg(feature = "ignore_duplicates")]
1725                                    {
1726                                        __A::skip_value(&mut __map)?;
1727                                        continue;
1728                                    }
1729                                    #[cfg(feature = "strict")]
1730                                    return _serde::__private::Err(
1731                                        <__A::Error as _serde::de::Error>::duplicate_field(
1732                                            "transitionToNextLowerStateEventId",
1733                                        ),
1734                                    );
1735                                }
1736                                m_transitionToNextLowerStateEventId = _serde::__private::Some(
1737                                    match __A::next_value::<i32>(&mut __map) {
1738                                        _serde::__private::Ok(__val) => __val,
1739                                        _serde::__private::Err(__err) => {
1740                                            return _serde::__private::Err(__err);
1741                                        }
1742                                    },
1743                                );
1744                            }
1745                            __Field::m_syncVariableIndex => {
1746                                #[cfg(
1747                                    any(feature = "strict", feature = "ignore_duplicates")
1748                                )]
1749                                if _serde::__private::Option::is_some(
1750                                    &m_syncVariableIndex,
1751                                ) {
1752                                    #[cfg(feature = "ignore_duplicates")]
1753                                    {
1754                                        __A::skip_value(&mut __map)?;
1755                                        continue;
1756                                    }
1757                                    #[cfg(feature = "strict")]
1758                                    return _serde::__private::Err(
1759                                        <__A::Error as _serde::de::Error>::duplicate_field(
1760                                            "syncVariableIndex",
1761                                        ),
1762                                    );
1763                                }
1764                                m_syncVariableIndex = _serde::__private::Some(
1765                                    match __A::next_value::<i32>(&mut __map) {
1766                                        _serde::__private::Ok(__val) => __val,
1767                                        _serde::__private::Err(__err) => {
1768                                            return _serde::__private::Err(__err);
1769                                        }
1770                                    },
1771                                );
1772                            }
1773                            __Field::m_wrapAroundStateId => {
1774                                #[cfg(
1775                                    any(feature = "strict", feature = "ignore_duplicates")
1776                                )]
1777                                if _serde::__private::Option::is_some(
1778                                    &m_wrapAroundStateId,
1779                                ) {
1780                                    #[cfg(feature = "ignore_duplicates")]
1781                                    {
1782                                        __A::skip_value(&mut __map)?;
1783                                        continue;
1784                                    }
1785                                    #[cfg(feature = "strict")]
1786                                    return _serde::__private::Err(
1787                                        <__A::Error as _serde::de::Error>::duplicate_field(
1788                                            "wrapAroundStateId",
1789                                        ),
1790                                    );
1791                                }
1792                                m_wrapAroundStateId = _serde::__private::Some(
1793                                    match __A::next_value::<bool>(&mut __map) {
1794                                        _serde::__private::Ok(__val) => __val,
1795                                        _serde::__private::Err(__err) => {
1796                                            return _serde::__private::Err(__err);
1797                                        }
1798                                    },
1799                                );
1800                            }
1801                            __Field::m_maxSimultaneousTransitions => {
1802                                #[cfg(
1803                                    any(feature = "strict", feature = "ignore_duplicates")
1804                                )]
1805                                if _serde::__private::Option::is_some(
1806                                    &m_maxSimultaneousTransitions,
1807                                ) {
1808                                    #[cfg(feature = "ignore_duplicates")]
1809                                    {
1810                                        __A::skip_value(&mut __map)?;
1811                                        continue;
1812                                    }
1813                                    #[cfg(feature = "strict")]
1814                                    return _serde::__private::Err(
1815                                        <__A::Error as _serde::de::Error>::duplicate_field(
1816                                            "maxSimultaneousTransitions",
1817                                        ),
1818                                    );
1819                                }
1820                                m_maxSimultaneousTransitions = _serde::__private::Some(
1821                                    match __A::next_value::<i8>(&mut __map) {
1822                                        _serde::__private::Ok(__val) => __val,
1823                                        _serde::__private::Err(__err) => {
1824                                            return _serde::__private::Err(__err);
1825                                        }
1826                                    },
1827                                );
1828                            }
1829                            __Field::m_startStateMode => {
1830                                #[cfg(
1831                                    any(feature = "strict", feature = "ignore_duplicates")
1832                                )]
1833                                if _serde::__private::Option::is_some(&m_startStateMode) {
1834                                    #[cfg(feature = "ignore_duplicates")]
1835                                    {
1836                                        __A::skip_value(&mut __map)?;
1837                                        continue;
1838                                    }
1839                                    #[cfg(feature = "strict")]
1840                                    return _serde::__private::Err(
1841                                        <__A::Error as _serde::de::Error>::duplicate_field(
1842                                            "startStateMode",
1843                                        ),
1844                                    );
1845                                }
1846                                m_startStateMode = _serde::__private::Some(
1847                                    match __A::next_value::<StartStateMode>(&mut __map) {
1848                                        _serde::__private::Ok(__val) => __val,
1849                                        _serde::__private::Err(__err) => {
1850                                            return _serde::__private::Err(__err);
1851                                        }
1852                                    },
1853                                );
1854                            }
1855                            __Field::m_selfTransitionMode => {
1856                                #[cfg(
1857                                    any(feature = "strict", feature = "ignore_duplicates")
1858                                )]
1859                                if _serde::__private::Option::is_some(
1860                                    &m_selfTransitionMode,
1861                                ) {
1862                                    #[cfg(feature = "ignore_duplicates")]
1863                                    {
1864                                        __A::skip_value(&mut __map)?;
1865                                        continue;
1866                                    }
1867                                    #[cfg(feature = "strict")]
1868                                    return _serde::__private::Err(
1869                                        <__A::Error as _serde::de::Error>::duplicate_field(
1870                                            "selfTransitionMode",
1871                                        ),
1872                                    );
1873                                }
1874                                m_selfTransitionMode = _serde::__private::Some(
1875                                    match __A::next_value::<
1876                                        StateMachineSelfTransitionMode,
1877                                    >(&mut __map) {
1878                                        _serde::__private::Ok(__val) => __val,
1879                                        _serde::__private::Err(__err) => {
1880                                            return _serde::__private::Err(__err);
1881                                        }
1882                                    },
1883                                );
1884                            }
1885                            __Field::m_states => {
1886                                #[cfg(
1887                                    any(feature = "strict", feature = "ignore_duplicates")
1888                                )]
1889                                if _serde::__private::Option::is_some(&m_states) {
1890                                    #[cfg(feature = "ignore_duplicates")]
1891                                    {
1892                                        __A::skip_value(&mut __map)?;
1893                                        continue;
1894                                    }
1895                                    #[cfg(feature = "strict")]
1896                                    return _serde::__private::Err(
1897                                        <__A::Error as _serde::de::Error>::duplicate_field("states"),
1898                                    );
1899                                }
1900                                m_states = _serde::__private::Some(
1901                                    match __A::next_value::<Vec<Pointer>>(&mut __map) {
1902                                        _serde::__private::Ok(__val) => __val,
1903                                        _serde::__private::Err(__err) => {
1904                                            return _serde::__private::Err(__err);
1905                                        }
1906                                    },
1907                                );
1908                            }
1909                            __Field::m_wildcardTransitions => {
1910                                #[cfg(
1911                                    any(feature = "strict", feature = "ignore_duplicates")
1912                                )]
1913                                if _serde::__private::Option::is_some(
1914                                    &m_wildcardTransitions,
1915                                ) {
1916                                    #[cfg(feature = "ignore_duplicates")]
1917                                    {
1918                                        __A::skip_value(&mut __map)?;
1919                                        continue;
1920                                    }
1921                                    #[cfg(feature = "strict")]
1922                                    return _serde::__private::Err(
1923                                        <__A::Error as _serde::de::Error>::duplicate_field(
1924                                            "wildcardTransitions",
1925                                        ),
1926                                    );
1927                                }
1928                                m_wildcardTransitions = _serde::__private::Some(
1929                                    match __A::next_value::<Pointer>(&mut __map) {
1930                                        _serde::__private::Ok(__val) => __val,
1931                                        _serde::__private::Err(__err) => {
1932                                            return _serde::__private::Err(__err);
1933                                        }
1934                                    },
1935                                );
1936                            }
1937                            _ => __A::skip_value(&mut __map)?,
1938                        }
1939                    }
1940                    let m_variableBindingSet = match m_variableBindingSet {
1941                        _serde::__private::Some(__field) => __field,
1942                        _serde::__private::None => {
1943                            #[cfg(feature = "strict")]
1944                            return _serde::__private::Err(
1945                                <__A::Error as _serde::de::Error>::missing_field(
1946                                    "variableBindingSet",
1947                                ),
1948                            );
1949                            #[cfg(not(feature = "strict"))] Default::default()
1950                        }
1951                    };
1952                    let m_userData = match m_userData {
1953                        _serde::__private::Some(__field) => __field,
1954                        _serde::__private::None => {
1955                            #[cfg(feature = "strict")]
1956                            return _serde::__private::Err(
1957                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1958                            );
1959                            #[cfg(not(feature = "strict"))] Default::default()
1960                        }
1961                    };
1962                    let m_name = match m_name {
1963                        _serde::__private::Some(__field) => __field,
1964                        _serde::__private::None => {
1965                            #[cfg(feature = "strict")]
1966                            return _serde::__private::Err(
1967                                <__A::Error as _serde::de::Error>::missing_field("name"),
1968                            );
1969                            #[cfg(not(feature = "strict"))] Default::default()
1970                        }
1971                    };
1972                    let m_eventToSendWhenStateOrTransitionChanges = match m_eventToSendWhenStateOrTransitionChanges {
1973                        _serde::__private::Some(__field) => __field,
1974                        _serde::__private::None => {
1975                            #[cfg(feature = "strict")]
1976                            return _serde::__private::Err(
1977                                <__A::Error as _serde::de::Error>::missing_field(
1978                                    "eventToSendWhenStateOrTransitionChanges",
1979                                ),
1980                            );
1981                            #[cfg(not(feature = "strict"))] Default::default()
1982                        }
1983                    };
1984                    let m_startStateChooser = match m_startStateChooser {
1985                        _serde::__private::Some(__field) => __field,
1986                        _serde::__private::None => {
1987                            #[cfg(feature = "strict")]
1988                            return _serde::__private::Err(
1989                                <__A::Error as _serde::de::Error>::missing_field(
1990                                    "startStateChooser",
1991                                ),
1992                            );
1993                            #[cfg(not(feature = "strict"))] Default::default()
1994                        }
1995                    };
1996                    let m_startStateId = match m_startStateId {
1997                        _serde::__private::Some(__field) => __field,
1998                        _serde::__private::None => {
1999                            #[cfg(feature = "strict")]
2000                            return _serde::__private::Err(
2001                                <__A::Error as _serde::de::Error>::missing_field(
2002                                    "startStateId",
2003                                ),
2004                            );
2005                            #[cfg(not(feature = "strict"))] Default::default()
2006                        }
2007                    };
2008                    let m_returnToPreviousStateEventId = match m_returnToPreviousStateEventId {
2009                        _serde::__private::Some(__field) => __field,
2010                        _serde::__private::None => {
2011                            #[cfg(feature = "strict")]
2012                            return _serde::__private::Err(
2013                                <__A::Error as _serde::de::Error>::missing_field(
2014                                    "returnToPreviousStateEventId",
2015                                ),
2016                            );
2017                            #[cfg(not(feature = "strict"))] Default::default()
2018                        }
2019                    };
2020                    let m_randomTransitionEventId = match m_randomTransitionEventId {
2021                        _serde::__private::Some(__field) => __field,
2022                        _serde::__private::None => {
2023                            #[cfg(feature = "strict")]
2024                            return _serde::__private::Err(
2025                                <__A::Error as _serde::de::Error>::missing_field(
2026                                    "randomTransitionEventId",
2027                                ),
2028                            );
2029                            #[cfg(not(feature = "strict"))] Default::default()
2030                        }
2031                    };
2032                    let m_transitionToNextHigherStateEventId = match m_transitionToNextHigherStateEventId {
2033                        _serde::__private::Some(__field) => __field,
2034                        _serde::__private::None => {
2035                            #[cfg(feature = "strict")]
2036                            return _serde::__private::Err(
2037                                <__A::Error as _serde::de::Error>::missing_field(
2038                                    "transitionToNextHigherStateEventId",
2039                                ),
2040                            );
2041                            #[cfg(not(feature = "strict"))] Default::default()
2042                        }
2043                    };
2044                    let m_transitionToNextLowerStateEventId = match m_transitionToNextLowerStateEventId {
2045                        _serde::__private::Some(__field) => __field,
2046                        _serde::__private::None => {
2047                            #[cfg(feature = "strict")]
2048                            return _serde::__private::Err(
2049                                <__A::Error as _serde::de::Error>::missing_field(
2050                                    "transitionToNextLowerStateEventId",
2051                                ),
2052                            );
2053                            #[cfg(not(feature = "strict"))] Default::default()
2054                        }
2055                    };
2056                    let m_syncVariableIndex = match m_syncVariableIndex {
2057                        _serde::__private::Some(__field) => __field,
2058                        _serde::__private::None => {
2059                            #[cfg(feature = "strict")]
2060                            return _serde::__private::Err(
2061                                <__A::Error as _serde::de::Error>::missing_field(
2062                                    "syncVariableIndex",
2063                                ),
2064                            );
2065                            #[cfg(not(feature = "strict"))] Default::default()
2066                        }
2067                    };
2068                    let m_wrapAroundStateId = match m_wrapAroundStateId {
2069                        _serde::__private::Some(__field) => __field,
2070                        _serde::__private::None => {
2071                            #[cfg(feature = "strict")]
2072                            return _serde::__private::Err(
2073                                <__A::Error as _serde::de::Error>::missing_field(
2074                                    "wrapAroundStateId",
2075                                ),
2076                            );
2077                            #[cfg(not(feature = "strict"))] Default::default()
2078                        }
2079                    };
2080                    let m_maxSimultaneousTransitions = match m_maxSimultaneousTransitions {
2081                        _serde::__private::Some(__field) => __field,
2082                        _serde::__private::None => {
2083                            #[cfg(feature = "strict")]
2084                            return _serde::__private::Err(
2085                                <__A::Error as _serde::de::Error>::missing_field(
2086                                    "maxSimultaneousTransitions",
2087                                ),
2088                            );
2089                            #[cfg(not(feature = "strict"))] Default::default()
2090                        }
2091                    };
2092                    let m_startStateMode = match m_startStateMode {
2093                        _serde::__private::Some(__field) => __field,
2094                        _serde::__private::None => {
2095                            #[cfg(feature = "strict")]
2096                            return _serde::__private::Err(
2097                                <__A::Error as _serde::de::Error>::missing_field(
2098                                    "startStateMode",
2099                                ),
2100                            );
2101                            #[cfg(not(feature = "strict"))] Default::default()
2102                        }
2103                    };
2104                    let m_selfTransitionMode = match m_selfTransitionMode {
2105                        _serde::__private::Some(__field) => __field,
2106                        _serde::__private::None => {
2107                            #[cfg(feature = "strict")]
2108                            return _serde::__private::Err(
2109                                <__A::Error as _serde::de::Error>::missing_field(
2110                                    "selfTransitionMode",
2111                                ),
2112                            );
2113                            #[cfg(not(feature = "strict"))] Default::default()
2114                        }
2115                    };
2116                    let m_states = match m_states {
2117                        _serde::__private::Some(__field) => __field,
2118                        _serde::__private::None => {
2119                            #[cfg(feature = "strict")]
2120                            return _serde::__private::Err(
2121                                <__A::Error as _serde::de::Error>::missing_field("states"),
2122                            );
2123                            #[cfg(not(feature = "strict"))] Default::default()
2124                        }
2125                    };
2126                    let m_wildcardTransitions = match m_wildcardTransitions {
2127                        _serde::__private::Some(__field) => __field,
2128                        _serde::__private::None => {
2129                            #[cfg(feature = "strict")]
2130                            return _serde::__private::Err(
2131                                <__A::Error as _serde::de::Error>::missing_field(
2132                                    "wildcardTransitions",
2133                                ),
2134                            );
2135                            #[cfg(not(feature = "strict"))] Default::default()
2136                        }
2137                    };
2138                    let __ptr = None;
2139                    let parent = hkBaseObject { __ptr };
2140                    let parent = hkReferencedObject {
2141                        __ptr,
2142                        parent,
2143                        ..Default::default()
2144                    };
2145                    let parent = hkbBindable {
2146                        __ptr,
2147                        parent,
2148                        m_variableBindingSet,
2149                        ..Default::default()
2150                    };
2151                    let parent = hkbNode {
2152                        __ptr,
2153                        parent,
2154                        m_userData,
2155                        m_name,
2156                        ..Default::default()
2157                    };
2158                    let parent = hkbGenerator { __ptr, parent };
2159                    let __ptr = __A::class_ptr(&mut __map);
2160                    _serde::__private::Ok(hkbStateMachine {
2161                        __ptr,
2162                        parent,
2163                        m_eventToSendWhenStateOrTransitionChanges,
2164                        m_startStateChooser,
2165                        m_startStateId,
2166                        m_returnToPreviousStateEventId,
2167                        m_randomTransitionEventId,
2168                        m_transitionToNextHigherStateEventId,
2169                        m_transitionToNextLowerStateEventId,
2170                        m_syncVariableIndex,
2171                        m_wrapAroundStateId,
2172                        m_maxSimultaneousTransitions,
2173                        m_startStateMode,
2174                        m_selfTransitionMode,
2175                        m_states,
2176                        m_wildcardTransitions,
2177                        ..Default::default()
2178                    })
2179                }
2180            }
2181            const FIELDS: &[&str] = &[
2182                "eventToSendWhenStateOrTransitionChanges",
2183                "startStateChooser",
2184                "startStateId",
2185                "returnToPreviousStateEventId",
2186                "randomTransitionEventId",
2187                "transitionToNextHigherStateEventId",
2188                "transitionToNextLowerStateEventId",
2189                "syncVariableIndex",
2190                "currentStateId",
2191                "wrapAroundStateId",
2192                "maxSimultaneousTransitions",
2193                "startStateMode",
2194                "selfTransitionMode",
2195                "isActive",
2196                "states",
2197                "wildcardTransitions",
2198                "stateIdToIndexMap",
2199                "activeTransitions",
2200                "transitionFlags",
2201                "wildcardTransitionFlags",
2202                "delayedTransitions",
2203                "timeInState",
2204                "lastLocalTime",
2205                "previousStateId",
2206                "nextStartStateIndexOverride",
2207                "stateOrTransitionChanged",
2208                "echoNextUpdate",
2209                "sCurrentStateIndexAndEntered",
2210            ];
2211            _serde::Deserializer::deserialize_struct(
2212                deserializer,
2213                "hkbStateMachine",
2214                FIELDS,
2215                __hkbStateMachineVisitor {
2216                    marker: _serde::__private::PhantomData::<hkbStateMachine>,
2217                    lifetime: _serde::__private::PhantomData,
2218                },
2219            )
2220        }
2221    }
2222};
2223/// # C++ Info
2224/// - name: `StartStateMode`(ctype: `hkEnum<StartStateMode, hkInt8>`)
2225#[allow(non_upper_case_globals, non_snake_case)]
2226#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2227#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2228#[derive(
2229    Debug,
2230    Clone,
2231    Default,
2232    PartialEq,
2233    Eq,
2234    PartialOrd,
2235    Ord,
2236    num_derive::ToPrimitive,
2237    num_derive::FromPrimitive,
2238)]
2239pub enum StartStateMode {
2240    #[default]
2241    START_STATE_MODE_DEFAULT = 0isize,
2242    START_STATE_MODE_SYNC = 1isize,
2243    START_STATE_MODE_RANDOM = 2isize,
2244    START_STATE_MODE_CHOOSER = 3isize,
2245}
2246/// # C++ Info
2247/// - name: `StateMachineSelfTransitionMode`(ctype: `hkEnum<StateMachineSelfTransitionMode, hkInt8>`)
2248#[allow(non_upper_case_globals, non_snake_case)]
2249#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2250#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2251#[derive(
2252    Debug,
2253    Clone,
2254    Default,
2255    PartialEq,
2256    Eq,
2257    PartialOrd,
2258    Ord,
2259    num_derive::ToPrimitive,
2260    num_derive::FromPrimitive,
2261)]
2262pub enum StateMachineSelfTransitionMode {
2263    #[default]
2264    SELF_TRANSITION_MODE_NO_TRANSITION = 0isize,
2265    SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE = 1isize,
2266    SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE = 2isize,
2267}
2268const _: () = {
2269    use havok_serde as __serde;
2270    impl __serde::Serialize for StartStateMode {
2271        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2272        where
2273            S: __serde::ser::Serializer,
2274        {
2275            let mut __serializer = __serializer.serialize_enum_flags()?;
2276            match self {
2277                Self::START_STATE_MODE_DEFAULT => {
2278                    __serializer.serialize_field("START_STATE_MODE_DEFAULT", &0u64)
2279                }
2280                Self::START_STATE_MODE_SYNC => {
2281                    __serializer.serialize_field("START_STATE_MODE_SYNC", &1u64)
2282                }
2283                Self::START_STATE_MODE_RANDOM => {
2284                    __serializer.serialize_field("START_STATE_MODE_RANDOM", &2u64)
2285                }
2286                Self::START_STATE_MODE_CHOOSER => {
2287                    __serializer.serialize_field("START_STATE_MODE_CHOOSER", &3u64)
2288                }
2289            }?;
2290            use num_traits::ToPrimitive as _;
2291            let num = self
2292                .to_i8()
2293                .ok_or(S::Error::custom("Failed enum StartStateMode to_i8"))?;
2294            __serializer.serialize_bits(&num)?;
2295            __serializer.end()
2296        }
2297    }
2298};
2299const _: () = {
2300    use havok_serde as __serde;
2301    impl __serde::Serialize for StateMachineSelfTransitionMode {
2302        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2303        where
2304            S: __serde::ser::Serializer,
2305        {
2306            let mut __serializer = __serializer.serialize_enum_flags()?;
2307            match self {
2308                Self::SELF_TRANSITION_MODE_NO_TRANSITION => {
2309                    __serializer
2310                        .serialize_field("SELF_TRANSITION_MODE_NO_TRANSITION", &0u64)
2311                }
2312                Self::SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE => {
2313                    __serializer
2314                        .serialize_field(
2315                            "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2316                            &1u64,
2317                        )
2318                }
2319                Self::SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE => {
2320                    __serializer
2321                        .serialize_field(
2322                            "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2323                            &2u64,
2324                        )
2325                }
2326            }?;
2327            use num_traits::ToPrimitive as _;
2328            let num = self
2329                .to_i8()
2330                .ok_or(
2331                    S::Error::custom("Failed enum StateMachineSelfTransitionMode to_i8"),
2332                )?;
2333            __serializer.serialize_bits(&num)?;
2334            __serializer.end()
2335        }
2336    }
2337};
2338#[doc(hidden)]
2339#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2340const _: () = {
2341    #[allow(unused_extern_crates, clippy::useless_attribute)]
2342    extern crate havok_serde as _serde;
2343    #[automatically_derived]
2344    impl<'de> _serde::Deserialize<'de> for StartStateMode {
2345        fn deserialize<__D>(
2346            __deserializer: __D,
2347        ) -> _serde::__private::Result<Self, __D::Error>
2348        where
2349            __D: _serde::Deserializer<'de>,
2350        {
2351            #[allow(non_camel_case_types)]
2352            #[doc(hidden)]
2353            enum __Field {
2354                __field0,
2355                __field1,
2356                __field2,
2357                __field3,
2358            }
2359            #[doc(hidden)]
2360            struct __FieldVisitor;
2361            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2362                type Value = __Field;
2363                fn expecting(
2364                    &self,
2365                    __formatter: &mut _serde::__private::Formatter,
2366                ) -> _serde::__private::fmt::Result {
2367                    _serde::__private::Formatter::write_str(
2368                        __formatter,
2369                        "variant identifier",
2370                    )
2371                }
2372                fn visit_int8<__E>(
2373                    self,
2374                    __value: i8,
2375                ) -> _serde::__private::Result<Self::Value, __E>
2376                where
2377                    __E: _serde::de::Error,
2378                {
2379                    match __value {
2380                        0i8 => _serde::__private::Ok(__Field::__field0),
2381                        1i8 => _serde::__private::Ok(__Field::__field1),
2382                        2i8 => _serde::__private::Ok(__Field::__field2),
2383                        3i8 => _serde::__private::Ok(__Field::__field3),
2384                        _ => {
2385                            _serde::__private::Err(
2386                                _serde::de::Error::invalid_value(
2387                                    _serde::de::Unexpected::Int8(__value),
2388                                    &"value(i8) of variant is one of 0, 1, 2, 3",
2389                                ),
2390                            )
2391                        }
2392                    }
2393                }
2394                fn visit_stringptr<__E>(
2395                    self,
2396                    __value: StringPtr<'de>,
2397                ) -> _serde::__private::Result<Self::Value, __E>
2398                where
2399                    __E: _serde::de::Error,
2400                {
2401                    if let Some(__value) = __value.into_inner() {
2402                        match __value.as_ref() {
2403                            v if v == "0"
2404                                || v.eq_ignore_ascii_case("START_STATE_MODE_DEFAULT") => {
2405                                _serde::__private::Ok(__Field::__field0)
2406                            }
2407                            v if v == "1"
2408                                || v.eq_ignore_ascii_case("START_STATE_MODE_SYNC") => {
2409                                _serde::__private::Ok(__Field::__field1)
2410                            }
2411                            v if v == "2"
2412                                || v.eq_ignore_ascii_case("START_STATE_MODE_RANDOM") => {
2413                                _serde::__private::Ok(__Field::__field2)
2414                            }
2415                            v if v == "3"
2416                                || v.eq_ignore_ascii_case("START_STATE_MODE_CHOOSER") => {
2417                                _serde::__private::Ok(__Field::__field3)
2418                            }
2419                            _ => {
2420                                _serde::__private::Err(
2421                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
2422                                )
2423                            }
2424                        }
2425                    } else {
2426                        _serde::__private::Err(
2427                            _serde::de::Error::unknown_variant("None", VARIANTS),
2428                        )
2429                    }
2430                }
2431            }
2432            impl<'de> _serde::Deserialize<'de> for __Field {
2433                #[inline]
2434                fn deserialize<__D>(
2435                    __deserializer: __D,
2436                ) -> _serde::__private::Result<Self, __D::Error>
2437                where
2438                    __D: _serde::Deserializer<'de>,
2439                {
2440                    _serde::Deserializer::deserialize_identifier(
2441                        __deserializer,
2442                        _serde::de::ReadEnumSize::Int8,
2443                        __FieldVisitor,
2444                    )
2445                }
2446            }
2447            #[doc(hidden)]
2448            struct __Visitor<'de> {
2449                marker: _serde::__private::PhantomData<StartStateMode>,
2450                lifetime: _serde::__private::PhantomData<&'de ()>,
2451            }
2452            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2453                type Value = StartStateMode;
2454                fn expecting(
2455                    &self,
2456                    __formatter: &mut _serde::__private::Formatter,
2457                ) -> _serde::__private::fmt::Result {
2458                    _serde::__private::Formatter::write_str(
2459                        __formatter,
2460                        "enum StartStateMode",
2461                    )
2462                }
2463                fn visit_enum<__A>(
2464                    self,
2465                    __data: __A,
2466                ) -> _serde::__private::Result<Self::Value, __A::Error>
2467                where
2468                    __A: _serde::de::EnumAccess<'de>,
2469                {
2470                    match _serde::de::EnumAccess::variant(__data)? {
2471                        (__Field::__field0, __variant) => {
2472                            _serde::de::VariantAccess::unit_variant(__variant)?;
2473                            _serde::__private::Ok(
2474                                StartStateMode::START_STATE_MODE_DEFAULT,
2475                            )
2476                        }
2477                        (__Field::__field1, __variant) => {
2478                            _serde::de::VariantAccess::unit_variant(__variant)?;
2479                            _serde::__private::Ok(StartStateMode::START_STATE_MODE_SYNC)
2480                        }
2481                        (__Field::__field2, __variant) => {
2482                            _serde::de::VariantAccess::unit_variant(__variant)?;
2483                            _serde::__private::Ok(
2484                                StartStateMode::START_STATE_MODE_RANDOM,
2485                            )
2486                        }
2487                        (__Field::__field3, __variant) => {
2488                            _serde::de::VariantAccess::unit_variant(__variant)?;
2489                            _serde::__private::Ok(
2490                                StartStateMode::START_STATE_MODE_CHOOSER,
2491                            )
2492                        }
2493                    }
2494                }
2495            }
2496            #[doc(hidden)]
2497            const VARIANTS: &'static [&'static str] = &[
2498                "START_STATE_MODE_DEFAULT",
2499                "START_STATE_MODE_SYNC",
2500                "START_STATE_MODE_RANDOM",
2501                "START_STATE_MODE_CHOOSER",
2502            ];
2503            _serde::Deserializer::deserialize_enum(
2504                __deserializer,
2505                "StartStateMode",
2506                VARIANTS,
2507                __Visitor {
2508                    marker: _serde::__private::PhantomData::<StartStateMode>,
2509                    lifetime: _serde::__private::PhantomData,
2510                },
2511            )
2512        }
2513    }
2514};
2515#[doc(hidden)]
2516#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2517const _: () = {
2518    #[allow(unused_extern_crates, clippy::useless_attribute)]
2519    extern crate havok_serde as _serde;
2520    #[automatically_derived]
2521    impl<'de> _serde::Deserialize<'de> for StateMachineSelfTransitionMode {
2522        fn deserialize<__D>(
2523            __deserializer: __D,
2524        ) -> _serde::__private::Result<Self, __D::Error>
2525        where
2526            __D: _serde::Deserializer<'de>,
2527        {
2528            #[allow(non_camel_case_types)]
2529            #[doc(hidden)]
2530            enum __Field {
2531                __field0,
2532                __field1,
2533                __field2,
2534            }
2535            #[doc(hidden)]
2536            struct __FieldVisitor;
2537            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2538                type Value = __Field;
2539                fn expecting(
2540                    &self,
2541                    __formatter: &mut _serde::__private::Formatter,
2542                ) -> _serde::__private::fmt::Result {
2543                    _serde::__private::Formatter::write_str(
2544                        __formatter,
2545                        "variant identifier",
2546                    )
2547                }
2548                fn visit_int8<__E>(
2549                    self,
2550                    __value: i8,
2551                ) -> _serde::__private::Result<Self::Value, __E>
2552                where
2553                    __E: _serde::de::Error,
2554                {
2555                    match __value {
2556                        0i8 => _serde::__private::Ok(__Field::__field0),
2557                        1i8 => _serde::__private::Ok(__Field::__field1),
2558                        2i8 => _serde::__private::Ok(__Field::__field2),
2559                        _ => {
2560                            _serde::__private::Err(
2561                                _serde::de::Error::invalid_value(
2562                                    _serde::de::Unexpected::Int8(__value),
2563                                    &"value(i8) of variant is one of 0, 1, 2",
2564                                ),
2565                            )
2566                        }
2567                    }
2568                }
2569                fn visit_stringptr<__E>(
2570                    self,
2571                    __value: StringPtr<'de>,
2572                ) -> _serde::__private::Result<Self::Value, __E>
2573                where
2574                    __E: _serde::de::Error,
2575                {
2576                    if let Some(__value) = __value.into_inner() {
2577                        match __value.as_ref() {
2578                            v if v == "0"
2579                                || v
2580                                    .eq_ignore_ascii_case(
2581                                        "SELF_TRANSITION_MODE_NO_TRANSITION",
2582                                    ) => _serde::__private::Ok(__Field::__field0),
2583                            v if v == "1"
2584                                || v
2585                                    .eq_ignore_ascii_case(
2586                                        "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2587                                    ) => _serde::__private::Ok(__Field::__field1),
2588                            v if v == "2"
2589                                || v
2590                                    .eq_ignore_ascii_case(
2591                                        "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2592                                    ) => _serde::__private::Ok(__Field::__field2),
2593                            _ => {
2594                                _serde::__private::Err(
2595                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
2596                                )
2597                            }
2598                        }
2599                    } else {
2600                        _serde::__private::Err(
2601                            _serde::de::Error::unknown_variant("None", VARIANTS),
2602                        )
2603                    }
2604                }
2605            }
2606            impl<'de> _serde::Deserialize<'de> for __Field {
2607                #[inline]
2608                fn deserialize<__D>(
2609                    __deserializer: __D,
2610                ) -> _serde::__private::Result<Self, __D::Error>
2611                where
2612                    __D: _serde::Deserializer<'de>,
2613                {
2614                    _serde::Deserializer::deserialize_identifier(
2615                        __deserializer,
2616                        _serde::de::ReadEnumSize::Int8,
2617                        __FieldVisitor,
2618                    )
2619                }
2620            }
2621            #[doc(hidden)]
2622            struct __Visitor<'de> {
2623                marker: _serde::__private::PhantomData<StateMachineSelfTransitionMode>,
2624                lifetime: _serde::__private::PhantomData<&'de ()>,
2625            }
2626            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2627                type Value = StateMachineSelfTransitionMode;
2628                fn expecting(
2629                    &self,
2630                    __formatter: &mut _serde::__private::Formatter,
2631                ) -> _serde::__private::fmt::Result {
2632                    _serde::__private::Formatter::write_str(
2633                        __formatter,
2634                        "enum StateMachineSelfTransitionMode",
2635                    )
2636                }
2637                fn visit_enum<__A>(
2638                    self,
2639                    __data: __A,
2640                ) -> _serde::__private::Result<Self::Value, __A::Error>
2641                where
2642                    __A: _serde::de::EnumAccess<'de>,
2643                {
2644                    match _serde::de::EnumAccess::variant(__data)? {
2645                        (__Field::__field0, __variant) => {
2646                            _serde::de::VariantAccess::unit_variant(__variant)?;
2647                            _serde::__private::Ok(
2648                                StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_NO_TRANSITION,
2649                            )
2650                        }
2651                        (__Field::__field1, __variant) => {
2652                            _serde::de::VariantAccess::unit_variant(__variant)?;
2653                            _serde::__private::Ok(
2654                                StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE,
2655                            )
2656                        }
2657                        (__Field::__field2, __variant) => {
2658                            _serde::de::VariantAccess::unit_variant(__variant)?;
2659                            _serde::__private::Ok(
2660                                StateMachineSelfTransitionMode::SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE,
2661                            )
2662                        }
2663                    }
2664                }
2665            }
2666            #[doc(hidden)]
2667            const VARIANTS: &'static [&'static str] = &[
2668                "SELF_TRANSITION_MODE_NO_TRANSITION",
2669                "SELF_TRANSITION_MODE_TRANSITION_TO_START_STATE",
2670                "SELF_TRANSITION_MODE_FORCE_TRANSITION_TO_START_STATE",
2671            ];
2672            _serde::Deserializer::deserialize_enum(
2673                __deserializer,
2674                "StateMachineSelfTransitionMode",
2675                VARIANTS,
2676                __Visitor {
2677                    marker: _serde::__private::PhantomData::<
2678                        StateMachineSelfTransitionMode,
2679                    >,
2680                    lifetime: _serde::__private::PhantomData,
2681                },
2682            )
2683        }
2684    }
2685};