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