1use super::class_requires::*;
2use super::*;
3#[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 hkpConstraintChainInstance<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkpConstraintInstance<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "chainedEntities"))]
36 #[cfg_attr(feature = "serde", serde(rename = "chainedEntities"))]
37 pub m_chainedEntities: Vec<Pointer>,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "action"))]
43 #[cfg_attr(feature = "serde", serde(rename = "action"))]
44 pub m_action: Pointer,
45}
46const _: () = {
47 use havok_serde as _serde;
48 impl<'a> _serde::HavokClass for hkpConstraintChainInstance<'a> {
49 #[inline]
50 fn name(&self) -> &'static str {
51 "hkpConstraintChainInstance"
52 }
53 #[inline]
54 fn signature(&self) -> _serde::__private::Signature {
55 _serde::__private::Signature::new(0x7a490753)
56 }
57 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
58 fn deps_indexes(&self) -> Vec<usize> {
59 let mut v = Vec::new();
60 v.push(self.parent.m_owner.get());
61 v.push(self.parent.m_data.get());
62 v.push(self.parent.m_constraintModifiers.get());
63 v.extend(self.parent.m_entities.iter().map(|ptr| ptr.get()));
64 v.extend(self.parent.m_listeners.deps_indexes());
65 v.push(self.parent.m_internal.get());
66 v.extend(self.m_chainedEntities.iter().map(|ptr| ptr.get()));
67 v.push(self.m_action.get());
68 v
69 }
70 }
71 impl<'a> _serde::Serialize for hkpConstraintChainInstance<'a> {
72 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
73 where
74 S: _serde::ser::Serializer,
75 {
76 let class_meta = self
77 .__ptr
78 .map(|name| (name, _serde::__private::Signature::new(0x7a490753)));
79 let mut serializer = __serializer
80 .serialize_struct(
81 "hkpConstraintChainInstance",
82 class_meta,
83 (72u64, 136u64),
84 )?;
85 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
86 serializer
87 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
88 serializer
89 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
90 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
91 serializer.skip_field("owner", &self.parent.m_owner)?;
92 serializer.serialize_field("data", &self.parent.m_data)?;
93 serializer
94 .serialize_field(
95 "constraintModifiers",
96 &self.parent.m_constraintModifiers,
97 )?;
98 serializer
99 .serialize_fixed_array_field(
100 "entities",
101 self.parent.m_entities.as_slice(),
102 TypeSize::NonPtr,
103 )?;
104 serializer.serialize_field("priority", &self.parent.m_priority)?;
105 serializer.serialize_field("wantRuntime", &self.parent.m_wantRuntime)?;
106 serializer
107 .serialize_field(
108 "destructionRemapInfo",
109 &self.parent.m_destructionRemapInfo,
110 )?;
111 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
112 serializer.skip_field("listeners", &self.parent.m_listeners)?;
113 serializer.serialize_field("name", &self.parent.m_name)?;
114 serializer.serialize_field("userData", &self.parent.m_userData)?;
115 serializer.skip_field("internal", &self.parent.m_internal)?;
116 serializer.skip_field("uid", &self.parent.m_uid)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer
119 .serialize_array_field(
120 "chainedEntities",
121 &self.m_chainedEntities,
122 TypeSize::NonPtr,
123 )?;
124 serializer.serialize_field("action", &self.m_action)?;
125 serializer.end()
126 }
127 }
128};
129#[doc(hidden)]
130#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
131const _: () = {
132 use havok_serde as _serde;
133 #[automatically_derived]
134 impl<'de> _serde::Deserialize<'de> for hkpConstraintChainInstance<'de> {
135 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
136 where
137 __D: _serde::Deserializer<'de>,
138 {
139 #[allow(non_camel_case_types)]
140 enum __Field {
141 m_data,
142 m_constraintModifiers,
143 m_entities,
144 m_priority,
145 m_wantRuntime,
146 m_destructionRemapInfo,
147 m_name,
148 m_userData,
149 m_chainedEntities,
150 m_action,
151 __ignore,
152 }
153 struct __FieldVisitor;
154 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
155 type Value = __Field;
156 fn expecting(
157 &self,
158 __formatter: &mut core::fmt::Formatter,
159 ) -> core::fmt::Result {
160 core::fmt::Formatter::write_str(__formatter, "field identifier")
161 }
162 #[allow(clippy::match_single_binding)]
164 #[allow(clippy::reversed_empty_ranges)]
165 #[allow(clippy::single_match)]
166 fn visit_key<__E>(
167 self,
168 __value: &str,
169 ) -> core::result::Result<Self::Value, __E>
170 where
171 __E: _serde::de::Error,
172 {
173 match __value {
174 "data" => Ok(__Field::m_data),
175 "constraintModifiers" => Ok(__Field::m_constraintModifiers),
176 "entities" => Ok(__Field::m_entities),
177 "priority" => Ok(__Field::m_priority),
178 "wantRuntime" => Ok(__Field::m_wantRuntime),
179 "destructionRemapInfo" => Ok(__Field::m_destructionRemapInfo),
180 "name" => Ok(__Field::m_name),
181 "userData" => Ok(__Field::m_userData),
182 "chainedEntities" => Ok(__Field::m_chainedEntities),
183 "action" => Ok(__Field::m_action),
184 _ => Ok(__Field::__ignore),
185 }
186 }
187 }
188 impl<'de> _serde::Deserialize<'de> for __Field {
189 #[inline]
190 fn deserialize<__D>(
191 __deserializer: __D,
192 ) -> core::result::Result<Self, __D::Error>
193 where
194 __D: _serde::Deserializer<'de>,
195 {
196 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
197 }
198 }
199 struct __hkpConstraintChainInstanceVisitor<'de> {
200 marker: _serde::__private::PhantomData<hkpConstraintChainInstance<'de>>,
201 lifetime: _serde::__private::PhantomData<&'de ()>,
202 }
203 #[allow(clippy::match_single_binding)]
204 #[allow(clippy::reversed_empty_ranges)]
205 #[allow(clippy::single_match)]
206 impl<'de> _serde::de::Visitor<'de>
207 for __hkpConstraintChainInstanceVisitor<'de> {
208 type Value = hkpConstraintChainInstance<'de>;
209 fn expecting(
210 &self,
211 __formatter: &mut core::fmt::Formatter,
212 ) -> core::fmt::Result {
213 core::fmt::Formatter::write_str(
214 __formatter,
215 "struct hkpConstraintChainInstance",
216 )
217 }
218 fn visit_struct_for_bytes<__A>(
219 self,
220 mut __map: __A,
221 ) -> _serde::__private::Result<Self::Value, __A::Error>
222 where
223 __A: _serde::de::MapAccess<'de>,
224 {
225 let __ptr = __A::class_ptr(&mut __map);
226 let parent = __A::parent_value(&mut __map)?;
227 let mut m_chainedEntities: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
228 let mut m_action: _serde::__private::Option<Pointer> = _serde::__private::None;
229 for i in 0..2usize {
230 match i {
231 0usize => {
232 if _serde::__private::Option::is_some(&m_chainedEntities) {
233 return _serde::__private::Err(
234 <__A::Error as _serde::de::Error>::duplicate_field(
235 "chainedEntities",
236 ),
237 );
238 }
239 m_chainedEntities = _serde::__private::Some(
240 match __A::next_value::<Vec<Pointer>>(&mut __map) {
241 _serde::__private::Ok(__val) => __val,
242 _serde::__private::Err(__err) => {
243 return _serde::__private::Err(__err);
244 }
245 },
246 );
247 }
248 1usize => {
249 if _serde::__private::Option::is_some(&m_action) {
250 return _serde::__private::Err(
251 <__A::Error as _serde::de::Error>::duplicate_field("action"),
252 );
253 }
254 m_action = _serde::__private::Some(
255 match __A::next_value::<Pointer>(&mut __map) {
256 _serde::__private::Ok(__val) => __val,
257 _serde::__private::Err(__err) => {
258 return _serde::__private::Err(__err);
259 }
260 },
261 );
262 }
263 _ => {}
264 }
265 }
266 let m_chainedEntities = match m_chainedEntities {
267 _serde::__private::Some(__field) => __field,
268 _serde::__private::None => {
269 return _serde::__private::Err(
270 <__A::Error as _serde::de::Error>::missing_field(
271 "chainedEntities",
272 ),
273 );
274 }
275 };
276 let m_action = match m_action {
277 _serde::__private::Some(__field) => __field,
278 _serde::__private::None => {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::missing_field("action"),
281 );
282 }
283 };
284 _serde::__private::Ok(hkpConstraintChainInstance {
285 __ptr,
286 parent,
287 m_chainedEntities,
288 m_action,
289 })
290 }
291 #[allow(clippy::manual_unwrap_or_default)]
292 fn visit_struct<__A>(
293 self,
294 mut __map: __A,
295 ) -> _serde::__private::Result<Self::Value, __A::Error>
296 where
297 __A: _serde::de::MapAccess<'de>,
298 {
299 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
300 let mut m_constraintModifiers: _serde::__private::Option<Pointer> = _serde::__private::None;
301 let mut m_entities: _serde::__private::Option<[Pointer; 2usize]> = _serde::__private::None;
302 let mut m_priority: _serde::__private::Option<ConstraintPriority> = _serde::__private::None;
303 let mut m_wantRuntime: _serde::__private::Option<bool> = _serde::__private::None;
304 let mut m_destructionRemapInfo: _serde::__private::Option<
305 OnDestructionRemapInfo,
306 > = _serde::__private::None;
307 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
308 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
309 let mut m_chainedEntities: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
310 let mut m_action: _serde::__private::Option<Pointer> = _serde::__private::None;
311 while let _serde::__private::Some(__key) = {
312 __A::next_key::<__Field>(&mut __map)?
313 } {
314 match __key {
315 __Field::m_data => {
316 #[cfg(
317 any(feature = "strict", feature = "ignore_duplicates")
318 )]
319 if _serde::__private::Option::is_some(&m_data) {
320 #[cfg(feature = "ignore_duplicates")]
321 {
322 __A::skip_value(&mut __map)?;
323 continue;
324 }
325 #[cfg(feature = "strict")]
326 return _serde::__private::Err(
327 <__A::Error as _serde::de::Error>::duplicate_field("data"),
328 );
329 }
330 m_data = _serde::__private::Some(
331 match __A::next_value::<Pointer>(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 __Field::m_constraintModifiers => {
340 #[cfg(
341 any(feature = "strict", feature = "ignore_duplicates")
342 )]
343 if _serde::__private::Option::is_some(
344 &m_constraintModifiers,
345 ) {
346 #[cfg(feature = "ignore_duplicates")]
347 {
348 __A::skip_value(&mut __map)?;
349 continue;
350 }
351 #[cfg(feature = "strict")]
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "constraintModifiers",
355 ),
356 );
357 }
358 m_constraintModifiers = _serde::__private::Some(
359 match __A::next_value::<Pointer>(&mut __map) {
360 _serde::__private::Ok(__val) => __val,
361 _serde::__private::Err(__err) => {
362 return _serde::__private::Err(__err);
363 }
364 },
365 );
366 }
367 __Field::m_entities => {
368 #[cfg(
369 any(feature = "strict", feature = "ignore_duplicates")
370 )]
371 if _serde::__private::Option::is_some(&m_entities) {
372 #[cfg(feature = "ignore_duplicates")]
373 {
374 __A::skip_value(&mut __map)?;
375 continue;
376 }
377 #[cfg(feature = "strict")]
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "entities",
381 ),
382 );
383 }
384 m_entities = _serde::__private::Some(
385 match __A::next_value::<[Pointer; 2usize]>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 __Field::m_priority => {
394 #[cfg(
395 any(feature = "strict", feature = "ignore_duplicates")
396 )]
397 if _serde::__private::Option::is_some(&m_priority) {
398 #[cfg(feature = "ignore_duplicates")]
399 {
400 __A::skip_value(&mut __map)?;
401 continue;
402 }
403 #[cfg(feature = "strict")]
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::duplicate_field(
406 "priority",
407 ),
408 );
409 }
410 m_priority = _serde::__private::Some(
411 match __A::next_value::<ConstraintPriority>(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 __Field::m_wantRuntime => {
420 #[cfg(
421 any(feature = "strict", feature = "ignore_duplicates")
422 )]
423 if _serde::__private::Option::is_some(&m_wantRuntime) {
424 #[cfg(feature = "ignore_duplicates")]
425 {
426 __A::skip_value(&mut __map)?;
427 continue;
428 }
429 #[cfg(feature = "strict")]
430 return _serde::__private::Err(
431 <__A::Error as _serde::de::Error>::duplicate_field(
432 "wantRuntime",
433 ),
434 );
435 }
436 m_wantRuntime = _serde::__private::Some(
437 match __A::next_value::<bool>(&mut __map) {
438 _serde::__private::Ok(__val) => __val,
439 _serde::__private::Err(__err) => {
440 return _serde::__private::Err(__err);
441 }
442 },
443 );
444 }
445 __Field::m_destructionRemapInfo => {
446 #[cfg(
447 any(feature = "strict", feature = "ignore_duplicates")
448 )]
449 if _serde::__private::Option::is_some(
450 &m_destructionRemapInfo,
451 ) {
452 #[cfg(feature = "ignore_duplicates")]
453 {
454 __A::skip_value(&mut __map)?;
455 continue;
456 }
457 #[cfg(feature = "strict")]
458 return _serde::__private::Err(
459 <__A::Error as _serde::de::Error>::duplicate_field(
460 "destructionRemapInfo",
461 ),
462 );
463 }
464 m_destructionRemapInfo = _serde::__private::Some(
465 match __A::next_value::<
466 OnDestructionRemapInfo,
467 >(&mut __map) {
468 _serde::__private::Ok(__val) => __val,
469 _serde::__private::Err(__err) => {
470 return _serde::__private::Err(__err);
471 }
472 },
473 );
474 }
475 __Field::m_name => {
476 #[cfg(
477 any(feature = "strict", feature = "ignore_duplicates")
478 )]
479 if _serde::__private::Option::is_some(&m_name) {
480 #[cfg(feature = "ignore_duplicates")]
481 {
482 __A::skip_value(&mut __map)?;
483 continue;
484 }
485 #[cfg(feature = "strict")]
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::duplicate_field("name"),
488 );
489 }
490 m_name = _serde::__private::Some(
491 match __A::next_value::<StringPtr<'de>>(&mut __map) {
492 _serde::__private::Ok(__val) => __val,
493 _serde::__private::Err(__err) => {
494 return _serde::__private::Err(__err);
495 }
496 },
497 );
498 }
499 __Field::m_userData => {
500 #[cfg(
501 any(feature = "strict", feature = "ignore_duplicates")
502 )]
503 if _serde::__private::Option::is_some(&m_userData) {
504 #[cfg(feature = "ignore_duplicates")]
505 {
506 __A::skip_value(&mut __map)?;
507 continue;
508 }
509 #[cfg(feature = "strict")]
510 return _serde::__private::Err(
511 <__A::Error as _serde::de::Error>::duplicate_field(
512 "userData",
513 ),
514 );
515 }
516 m_userData = _serde::__private::Some(
517 match __A::next_value::<Ulong>(&mut __map) {
518 _serde::__private::Ok(__val) => __val,
519 _serde::__private::Err(__err) => {
520 return _serde::__private::Err(__err);
521 }
522 },
523 );
524 }
525 __Field::m_chainedEntities => {
526 #[cfg(
527 any(feature = "strict", feature = "ignore_duplicates")
528 )]
529 if _serde::__private::Option::is_some(&m_chainedEntities) {
530 #[cfg(feature = "ignore_duplicates")]
531 {
532 __A::skip_value(&mut __map)?;
533 continue;
534 }
535 #[cfg(feature = "strict")]
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::duplicate_field(
538 "chainedEntities",
539 ),
540 );
541 }
542 m_chainedEntities = _serde::__private::Some(
543 match __A::next_value::<Vec<Pointer>>(&mut __map) {
544 _serde::__private::Ok(__val) => __val,
545 _serde::__private::Err(__err) => {
546 return _serde::__private::Err(__err);
547 }
548 },
549 );
550 }
551 __Field::m_action => {
552 #[cfg(
553 any(feature = "strict", feature = "ignore_duplicates")
554 )]
555 if _serde::__private::Option::is_some(&m_action) {
556 #[cfg(feature = "ignore_duplicates")]
557 {
558 __A::skip_value(&mut __map)?;
559 continue;
560 }
561 #[cfg(feature = "strict")]
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::duplicate_field("action"),
564 );
565 }
566 m_action = _serde::__private::Some(
567 match __A::next_value::<Pointer>(&mut __map) {
568 _serde::__private::Ok(__val) => __val,
569 _serde::__private::Err(__err) => {
570 return _serde::__private::Err(__err);
571 }
572 },
573 );
574 }
575 _ => __A::skip_value(&mut __map)?,
576 }
577 }
578 let m_data = match m_data {
579 _serde::__private::Some(__field) => __field,
580 _serde::__private::None => {
581 #[cfg(feature = "strict")]
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::missing_field("data"),
584 );
585 #[cfg(not(feature = "strict"))] Default::default()
586 }
587 };
588 let m_constraintModifiers = match m_constraintModifiers {
589 _serde::__private::Some(__field) => __field,
590 _serde::__private::None => {
591 #[cfg(feature = "strict")]
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::missing_field(
594 "constraintModifiers",
595 ),
596 );
597 #[cfg(not(feature = "strict"))] Default::default()
598 }
599 };
600 let m_entities = match m_entities {
601 _serde::__private::Some(__field) => __field,
602 _serde::__private::None => {
603 #[cfg(feature = "strict")]
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::missing_field("entities"),
606 );
607 #[cfg(not(feature = "strict"))] Default::default()
608 }
609 };
610 let m_priority = match m_priority {
611 _serde::__private::Some(__field) => __field,
612 _serde::__private::None => {
613 #[cfg(feature = "strict")]
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::missing_field("priority"),
616 );
617 #[cfg(not(feature = "strict"))] Default::default()
618 }
619 };
620 let m_wantRuntime = match m_wantRuntime {
621 _serde::__private::Some(__field) => __field,
622 _serde::__private::None => {
623 #[cfg(feature = "strict")]
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::missing_field(
626 "wantRuntime",
627 ),
628 );
629 #[cfg(not(feature = "strict"))] Default::default()
630 }
631 };
632 let m_destructionRemapInfo = match m_destructionRemapInfo {
633 _serde::__private::Some(__field) => __field,
634 _serde::__private::None => {
635 #[cfg(feature = "strict")]
636 return _serde::__private::Err(
637 <__A::Error as _serde::de::Error>::missing_field(
638 "destructionRemapInfo",
639 ),
640 );
641 #[cfg(not(feature = "strict"))] Default::default()
642 }
643 };
644 let m_name = match m_name {
645 _serde::__private::Some(__field) => __field,
646 _serde::__private::None => {
647 #[cfg(feature = "strict")]
648 return _serde::__private::Err(
649 <__A::Error as _serde::de::Error>::missing_field("name"),
650 );
651 #[cfg(not(feature = "strict"))] Default::default()
652 }
653 };
654 let m_userData = match m_userData {
655 _serde::__private::Some(__field) => __field,
656 _serde::__private::None => {
657 #[cfg(feature = "strict")]
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::missing_field("userData"),
660 );
661 #[cfg(not(feature = "strict"))] Default::default()
662 }
663 };
664 let m_chainedEntities = match m_chainedEntities {
665 _serde::__private::Some(__field) => __field,
666 _serde::__private::None => {
667 #[cfg(feature = "strict")]
668 return _serde::__private::Err(
669 <__A::Error as _serde::de::Error>::missing_field(
670 "chainedEntities",
671 ),
672 );
673 #[cfg(not(feature = "strict"))] Default::default()
674 }
675 };
676 let m_action = match m_action {
677 _serde::__private::Some(__field) => __field,
678 _serde::__private::None => {
679 #[cfg(feature = "strict")]
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::missing_field("action"),
682 );
683 #[cfg(not(feature = "strict"))] Default::default()
684 }
685 };
686 let __ptr = None;
687 let parent = hkBaseObject { __ptr };
688 let parent = hkReferencedObject {
689 __ptr,
690 parent,
691 ..Default::default()
692 };
693 let parent = hkpConstraintInstance {
694 __ptr,
695 parent,
696 m_data,
697 m_constraintModifiers,
698 m_entities,
699 m_priority,
700 m_wantRuntime,
701 m_destructionRemapInfo,
702 m_name,
703 m_userData,
704 ..Default::default()
705 };
706 let __ptr = __A::class_ptr(&mut __map);
707 _serde::__private::Ok(hkpConstraintChainInstance {
708 __ptr,
709 parent,
710 m_chainedEntities,
711 m_action,
712 })
713 }
714 }
715 const FIELDS: &[&str] = &["chainedEntities", "action"];
716 _serde::Deserializer::deserialize_struct(
717 deserializer,
718 "hkpConstraintChainInstance",
719 FIELDS,
720 __hkpConstraintChainInstanceVisitor {
721 marker: _serde::__private::PhantomData::<hkpConstraintChainInstance>,
722 lifetime: _serde::__private::PhantomData,
723 },
724 )
725 }
726 }
727};