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