1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct LymphaticVessel {
6 pub r#originates_from: Vec<OriginatesFromProperty>,
8 pub r#region_drained: Vec<RegionDrainedProperty>,
10 pub r#runs_to: Vec<RunsToProperty>,
12 pub r#associated_pathophysiology: Vec<AssociatedPathophysiologyProperty>,
14 pub r#body_location: Vec<BodyLocationProperty>,
16 pub r#connected_to: Vec<ConnectedToProperty>,
18 pub r#diagram: Vec<DiagramProperty>,
20 pub r#part_of_system: Vec<PartOfSystemProperty>,
22 pub r#related_condition: Vec<RelatedConditionProperty>,
24 pub r#related_therapy: Vec<RelatedTherapyProperty>,
26 pub r#sub_structure: Vec<SubStructureProperty>,
28 pub r#code: Vec<CodeProperty>,
30 pub r#funding: Vec<FundingProperty>,
32 pub r#guideline: Vec<GuidelineProperty>,
34 pub r#legal_status: Vec<LegalStatusProperty>,
36 pub r#medicine_system: Vec<MedicineSystemProperty>,
38 pub r#recognizing_authority: Vec<RecognizingAuthorityProperty>,
40 pub r#relevant_specialty: Vec<RelevantSpecialtyProperty>,
42 pub r#study: Vec<StudyProperty>,
44 pub r#additional_type: Vec<AdditionalTypeProperty>,
46 pub r#alternate_name: Vec<AlternateNameProperty>,
48 pub r#description: Vec<DescriptionProperty>,
50 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
52 pub r#identifier: Vec<IdentifierProperty>,
54 pub r#image: Vec<ImageProperty>,
56 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
58 pub r#name: Vec<NameProperty>,
60 pub r#potential_action: Vec<PotentialActionProperty>,
62 pub r#same_as: Vec<SameAsProperty>,
64 pub r#subject_of: Vec<SubjectOfProperty>,
66 pub r#url: Vec<UrlProperty>,
68}
69pub trait LymphaticVesselTrait {
71 fn get_originates_from(&self) -> &[OriginatesFromProperty];
73 fn take_originates_from(&mut self) -> Vec<OriginatesFromProperty>;
75 fn get_region_drained(&self) -> &[RegionDrainedProperty];
77 fn take_region_drained(&mut self) -> Vec<RegionDrainedProperty>;
79 fn get_runs_to(&self) -> &[RunsToProperty];
81 fn take_runs_to(&mut self) -> Vec<RunsToProperty>;
83}
84impl LymphaticVesselTrait for LymphaticVessel {
85 fn get_originates_from(&self) -> &[OriginatesFromProperty] {
86 self.r#originates_from.as_slice()
87 }
88 fn take_originates_from(&mut self) -> Vec<OriginatesFromProperty> {
89 std::mem::take(&mut self.r#originates_from)
90 }
91 fn get_region_drained(&self) -> &[RegionDrainedProperty] {
92 self.r#region_drained.as_slice()
93 }
94 fn take_region_drained(&mut self) -> Vec<RegionDrainedProperty> {
95 std::mem::take(&mut self.r#region_drained)
96 }
97 fn get_runs_to(&self) -> &[RunsToProperty] {
98 self.r#runs_to.as_slice()
99 }
100 fn take_runs_to(&mut self) -> Vec<RunsToProperty> {
101 std::mem::take(&mut self.r#runs_to)
102 }
103}
104impl AnatomicalStructureTrait for LymphaticVessel {
105 fn get_associated_pathophysiology(&self) -> &[AssociatedPathophysiologyProperty] {
106 self.r#associated_pathophysiology.as_slice()
107 }
108 fn take_associated_pathophysiology(&mut self) -> Vec<AssociatedPathophysiologyProperty> {
109 std::mem::take(&mut self.r#associated_pathophysiology)
110 }
111 fn get_body_location(&self) -> &[BodyLocationProperty] {
112 self.r#body_location.as_slice()
113 }
114 fn take_body_location(&mut self) -> Vec<BodyLocationProperty> {
115 std::mem::take(&mut self.r#body_location)
116 }
117 fn get_connected_to(&self) -> &[ConnectedToProperty] {
118 self.r#connected_to.as_slice()
119 }
120 fn take_connected_to(&mut self) -> Vec<ConnectedToProperty> {
121 std::mem::take(&mut self.r#connected_to)
122 }
123 fn get_diagram(&self) -> &[DiagramProperty] {
124 self.r#diagram.as_slice()
125 }
126 fn take_diagram(&mut self) -> Vec<DiagramProperty> {
127 std::mem::take(&mut self.r#diagram)
128 }
129 fn get_part_of_system(&self) -> &[PartOfSystemProperty] {
130 self.r#part_of_system.as_slice()
131 }
132 fn take_part_of_system(&mut self) -> Vec<PartOfSystemProperty> {
133 std::mem::take(&mut self.r#part_of_system)
134 }
135 fn get_related_condition(&self) -> &[RelatedConditionProperty] {
136 self.r#related_condition.as_slice()
137 }
138 fn take_related_condition(&mut self) -> Vec<RelatedConditionProperty> {
139 std::mem::take(&mut self.r#related_condition)
140 }
141 fn get_related_therapy(&self) -> &[RelatedTherapyProperty] {
142 self.r#related_therapy.as_slice()
143 }
144 fn take_related_therapy(&mut self) -> Vec<RelatedTherapyProperty> {
145 std::mem::take(&mut self.r#related_therapy)
146 }
147 fn get_sub_structure(&self) -> &[SubStructureProperty] {
148 self.r#sub_structure.as_slice()
149 }
150 fn take_sub_structure(&mut self) -> Vec<SubStructureProperty> {
151 std::mem::take(&mut self.r#sub_structure)
152 }
153}
154impl MedicalEntityTrait for LymphaticVessel {
155 fn get_code(&self) -> &[CodeProperty] {
156 self.r#code.as_slice()
157 }
158 fn take_code(&mut self) -> Vec<CodeProperty> {
159 std::mem::take(&mut self.r#code)
160 }
161 fn get_funding(&self) -> &[FundingProperty] {
162 self.r#funding.as_slice()
163 }
164 fn take_funding(&mut self) -> Vec<FundingProperty> {
165 std::mem::take(&mut self.r#funding)
166 }
167 fn get_guideline(&self) -> &[GuidelineProperty] {
168 self.r#guideline.as_slice()
169 }
170 fn take_guideline(&mut self) -> Vec<GuidelineProperty> {
171 std::mem::take(&mut self.r#guideline)
172 }
173 fn get_legal_status(&self) -> &[LegalStatusProperty] {
174 self.r#legal_status.as_slice()
175 }
176 fn take_legal_status(&mut self) -> Vec<LegalStatusProperty> {
177 std::mem::take(&mut self.r#legal_status)
178 }
179 fn get_medicine_system(&self) -> &[MedicineSystemProperty] {
180 self.r#medicine_system.as_slice()
181 }
182 fn take_medicine_system(&mut self) -> Vec<MedicineSystemProperty> {
183 std::mem::take(&mut self.r#medicine_system)
184 }
185 fn get_recognizing_authority(&self) -> &[RecognizingAuthorityProperty] {
186 self.r#recognizing_authority.as_slice()
187 }
188 fn take_recognizing_authority(&mut self) -> Vec<RecognizingAuthorityProperty> {
189 std::mem::take(&mut self.r#recognizing_authority)
190 }
191 fn get_relevant_specialty(&self) -> &[RelevantSpecialtyProperty] {
192 self.r#relevant_specialty.as_slice()
193 }
194 fn take_relevant_specialty(&mut self) -> Vec<RelevantSpecialtyProperty> {
195 std::mem::take(&mut self.r#relevant_specialty)
196 }
197 fn get_study(&self) -> &[StudyProperty] {
198 self.r#study.as_slice()
199 }
200 fn take_study(&mut self) -> Vec<StudyProperty> {
201 std::mem::take(&mut self.r#study)
202 }
203}
204impl ThingTrait for LymphaticVessel {
205 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
206 self.r#additional_type.as_slice()
207 }
208 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
209 std::mem::take(&mut self.r#additional_type)
210 }
211 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
212 self.r#alternate_name.as_slice()
213 }
214 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
215 std::mem::take(&mut self.r#alternate_name)
216 }
217 fn get_description(&self) -> &[DescriptionProperty] {
218 self.r#description.as_slice()
219 }
220 fn take_description(&mut self) -> Vec<DescriptionProperty> {
221 std::mem::take(&mut self.r#description)
222 }
223 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
224 self.r#disambiguating_description.as_slice()
225 }
226 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
227 std::mem::take(&mut self.r#disambiguating_description)
228 }
229 fn get_identifier(&self) -> &[IdentifierProperty] {
230 self.r#identifier.as_slice()
231 }
232 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
233 std::mem::take(&mut self.r#identifier)
234 }
235 fn get_image(&self) -> &[ImageProperty] {
236 self.r#image.as_slice()
237 }
238 fn take_image(&mut self) -> Vec<ImageProperty> {
239 std::mem::take(&mut self.r#image)
240 }
241 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
242 self.r#main_entity_of_page.as_slice()
243 }
244 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
245 std::mem::take(&mut self.r#main_entity_of_page)
246 }
247 fn get_name(&self) -> &[NameProperty] {
248 self.r#name.as_slice()
249 }
250 fn take_name(&mut self) -> Vec<NameProperty> {
251 std::mem::take(&mut self.r#name)
252 }
253 fn get_potential_action(&self) -> &[PotentialActionProperty] {
254 self.r#potential_action.as_slice()
255 }
256 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
257 std::mem::take(&mut self.r#potential_action)
258 }
259 fn get_same_as(&self) -> &[SameAsProperty] {
260 self.r#same_as.as_slice()
261 }
262 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
263 std::mem::take(&mut self.r#same_as)
264 }
265 fn get_subject_of(&self) -> &[SubjectOfProperty] {
266 self.r#subject_of.as_slice()
267 }
268 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
269 std::mem::take(&mut self.r#subject_of)
270 }
271 fn get_url(&self) -> &[UrlProperty] {
272 self.r#url.as_slice()
273 }
274 fn take_url(&mut self) -> Vec<UrlProperty> {
275 std::mem::take(&mut self.r#url)
276 }
277}
278impl VesselTrait for LymphaticVessel {}
279#[cfg(feature = "serde")]
280mod serde {
281 use std::{fmt, fmt::Formatter};
282
283 use ::serde::{
284 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
285 };
286
287 use super::*;
288 impl Serialize for LymphaticVessel {
289 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
290 where
291 S: Serializer,
292 {
293 let len: usize = [
294 !Vec::is_empty(&self.r#originates_from) as usize,
295 !Vec::is_empty(&self.r#region_drained) as usize,
296 !Vec::is_empty(&self.r#runs_to) as usize,
297 !Vec::is_empty(&self.r#associated_pathophysiology) as usize,
298 !Vec::is_empty(&self.r#body_location) as usize,
299 !Vec::is_empty(&self.r#connected_to) as usize,
300 !Vec::is_empty(&self.r#diagram) as usize,
301 !Vec::is_empty(&self.r#part_of_system) as usize,
302 !Vec::is_empty(&self.r#related_condition) as usize,
303 !Vec::is_empty(&self.r#related_therapy) as usize,
304 !Vec::is_empty(&self.r#sub_structure) as usize,
305 !Vec::is_empty(&self.r#code) as usize,
306 !Vec::is_empty(&self.r#funding) as usize,
307 !Vec::is_empty(&self.r#guideline) as usize,
308 !Vec::is_empty(&self.r#legal_status) as usize,
309 !Vec::is_empty(&self.r#medicine_system) as usize,
310 !Vec::is_empty(&self.r#recognizing_authority) as usize,
311 !Vec::is_empty(&self.r#relevant_specialty) as usize,
312 !Vec::is_empty(&self.r#study) as usize,
313 !Vec::is_empty(&self.r#additional_type) as usize,
314 !Vec::is_empty(&self.r#alternate_name) as usize,
315 !Vec::is_empty(&self.r#description) as usize,
316 !Vec::is_empty(&self.r#disambiguating_description) as usize,
317 !Vec::is_empty(&self.r#identifier) as usize,
318 !Vec::is_empty(&self.r#image) as usize,
319 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
320 !Vec::is_empty(&self.r#name) as usize,
321 !Vec::is_empty(&self.r#potential_action) as usize,
322 !Vec::is_empty(&self.r#same_as) as usize,
323 !Vec::is_empty(&self.r#subject_of) as usize,
324 !Vec::is_empty(&self.r#url) as usize,
325 ]
326 .iter()
327 .sum();
328 let mut serialize_struct =
329 Serializer::serialize_struct(serializer, "LymphaticVessel", len)?;
330 if !Vec::is_empty(&self.r#originates_from) {
331 serialize_struct.serialize_field("originatesFrom", {
332 struct SerializeWith<'a>(&'a Vec<OriginatesFromProperty>);
333 impl<'a> Serialize for SerializeWith<'a> {
334 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
335 where
336 S: Serializer,
337 {
338 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
339 self.0, serializer,
340 )
341 }
342 }
343 &SerializeWith(&self.r#originates_from)
344 })?;
345 } else {
346 serialize_struct.skip_field("originatesFrom")?;
347 }
348 if !Vec::is_empty(&self.r#region_drained) {
349 serialize_struct.serialize_field("regionDrained", {
350 struct SerializeWith<'a>(&'a Vec<RegionDrainedProperty>);
351 impl<'a> Serialize for SerializeWith<'a> {
352 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
353 where
354 S: Serializer,
355 {
356 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
357 self.0, serializer,
358 )
359 }
360 }
361 &SerializeWith(&self.r#region_drained)
362 })?;
363 } else {
364 serialize_struct.skip_field("regionDrained")?;
365 }
366 if !Vec::is_empty(&self.r#runs_to) {
367 serialize_struct.serialize_field("runsTo", {
368 struct SerializeWith<'a>(&'a Vec<RunsToProperty>);
369 impl<'a> Serialize for SerializeWith<'a> {
370 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
371 where
372 S: Serializer,
373 {
374 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
375 self.0, serializer,
376 )
377 }
378 }
379 &SerializeWith(&self.r#runs_to)
380 })?;
381 } else {
382 serialize_struct.skip_field("runsTo")?;
383 }
384 if !Vec::is_empty(&self.r#associated_pathophysiology) {
385 serialize_struct.serialize_field("associatedPathophysiology", {
386 struct SerializeWith<'a>(&'a Vec<AssociatedPathophysiologyProperty>);
387 impl<'a> Serialize for SerializeWith<'a> {
388 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
389 where
390 S: Serializer,
391 {
392 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
393 self.0, serializer,
394 )
395 }
396 }
397 &SerializeWith(&self.r#associated_pathophysiology)
398 })?;
399 } else {
400 serialize_struct.skip_field("associatedPathophysiology")?;
401 }
402 if !Vec::is_empty(&self.r#body_location) {
403 serialize_struct.serialize_field("bodyLocation", {
404 struct SerializeWith<'a>(&'a Vec<BodyLocationProperty>);
405 impl<'a> Serialize for SerializeWith<'a> {
406 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
407 where
408 S: Serializer,
409 {
410 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
411 self.0, serializer,
412 )
413 }
414 }
415 &SerializeWith(&self.r#body_location)
416 })?;
417 } else {
418 serialize_struct.skip_field("bodyLocation")?;
419 }
420 if !Vec::is_empty(&self.r#connected_to) {
421 serialize_struct.serialize_field("connectedTo", {
422 struct SerializeWith<'a>(&'a Vec<ConnectedToProperty>);
423 impl<'a> Serialize for SerializeWith<'a> {
424 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
425 where
426 S: Serializer,
427 {
428 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
429 self.0, serializer,
430 )
431 }
432 }
433 &SerializeWith(&self.r#connected_to)
434 })?;
435 } else {
436 serialize_struct.skip_field("connectedTo")?;
437 }
438 if !Vec::is_empty(&self.r#diagram) {
439 serialize_struct.serialize_field("diagram", {
440 struct SerializeWith<'a>(&'a Vec<DiagramProperty>);
441 impl<'a> Serialize for SerializeWith<'a> {
442 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
443 where
444 S: Serializer,
445 {
446 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
447 self.0, serializer,
448 )
449 }
450 }
451 &SerializeWith(&self.r#diagram)
452 })?;
453 } else {
454 serialize_struct.skip_field("diagram")?;
455 }
456 if !Vec::is_empty(&self.r#part_of_system) {
457 serialize_struct.serialize_field("partOfSystem", {
458 struct SerializeWith<'a>(&'a Vec<PartOfSystemProperty>);
459 impl<'a> Serialize for SerializeWith<'a> {
460 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
461 where
462 S: Serializer,
463 {
464 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
465 self.0, serializer,
466 )
467 }
468 }
469 &SerializeWith(&self.r#part_of_system)
470 })?;
471 } else {
472 serialize_struct.skip_field("partOfSystem")?;
473 }
474 if !Vec::is_empty(&self.r#related_condition) {
475 serialize_struct.serialize_field("relatedCondition", {
476 struct SerializeWith<'a>(&'a Vec<RelatedConditionProperty>);
477 impl<'a> Serialize for SerializeWith<'a> {
478 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
479 where
480 S: Serializer,
481 {
482 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
483 self.0, serializer,
484 )
485 }
486 }
487 &SerializeWith(&self.r#related_condition)
488 })?;
489 } else {
490 serialize_struct.skip_field("relatedCondition")?;
491 }
492 if !Vec::is_empty(&self.r#related_therapy) {
493 serialize_struct.serialize_field("relatedTherapy", {
494 struct SerializeWith<'a>(&'a Vec<RelatedTherapyProperty>);
495 impl<'a> Serialize for SerializeWith<'a> {
496 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
497 where
498 S: Serializer,
499 {
500 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
501 self.0, serializer,
502 )
503 }
504 }
505 &SerializeWith(&self.r#related_therapy)
506 })?;
507 } else {
508 serialize_struct.skip_field("relatedTherapy")?;
509 }
510 if !Vec::is_empty(&self.r#sub_structure) {
511 serialize_struct.serialize_field("subStructure", {
512 struct SerializeWith<'a>(&'a Vec<SubStructureProperty>);
513 impl<'a> Serialize for SerializeWith<'a> {
514 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
515 where
516 S: Serializer,
517 {
518 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
519 self.0, serializer,
520 )
521 }
522 }
523 &SerializeWith(&self.r#sub_structure)
524 })?;
525 } else {
526 serialize_struct.skip_field("subStructure")?;
527 }
528 if !Vec::is_empty(&self.r#code) {
529 serialize_struct.serialize_field("code", {
530 struct SerializeWith<'a>(&'a Vec<CodeProperty>);
531 impl<'a> Serialize for SerializeWith<'a> {
532 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533 where
534 S: Serializer,
535 {
536 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
537 self.0, serializer,
538 )
539 }
540 }
541 &SerializeWith(&self.r#code)
542 })?;
543 } else {
544 serialize_struct.skip_field("code")?;
545 }
546 if !Vec::is_empty(&self.r#funding) {
547 serialize_struct.serialize_field("funding", {
548 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
549 impl<'a> Serialize for SerializeWith<'a> {
550 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
551 where
552 S: Serializer,
553 {
554 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
555 self.0, serializer,
556 )
557 }
558 }
559 &SerializeWith(&self.r#funding)
560 })?;
561 } else {
562 serialize_struct.skip_field("funding")?;
563 }
564 if !Vec::is_empty(&self.r#guideline) {
565 serialize_struct.serialize_field("guideline", {
566 struct SerializeWith<'a>(&'a Vec<GuidelineProperty>);
567 impl<'a> Serialize for SerializeWith<'a> {
568 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
569 where
570 S: Serializer,
571 {
572 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
573 self.0, serializer,
574 )
575 }
576 }
577 &SerializeWith(&self.r#guideline)
578 })?;
579 } else {
580 serialize_struct.skip_field("guideline")?;
581 }
582 if !Vec::is_empty(&self.r#legal_status) {
583 serialize_struct.serialize_field("legalStatus", {
584 struct SerializeWith<'a>(&'a Vec<LegalStatusProperty>);
585 impl<'a> Serialize for SerializeWith<'a> {
586 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
587 where
588 S: Serializer,
589 {
590 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
591 self.0, serializer,
592 )
593 }
594 }
595 &SerializeWith(&self.r#legal_status)
596 })?;
597 } else {
598 serialize_struct.skip_field("legalStatus")?;
599 }
600 if !Vec::is_empty(&self.r#medicine_system) {
601 serialize_struct.serialize_field("medicineSystem", {
602 struct SerializeWith<'a>(&'a Vec<MedicineSystemProperty>);
603 impl<'a> Serialize for SerializeWith<'a> {
604 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
605 where
606 S: Serializer,
607 {
608 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
609 self.0, serializer,
610 )
611 }
612 }
613 &SerializeWith(&self.r#medicine_system)
614 })?;
615 } else {
616 serialize_struct.skip_field("medicineSystem")?;
617 }
618 if !Vec::is_empty(&self.r#recognizing_authority) {
619 serialize_struct.serialize_field("recognizingAuthority", {
620 struct SerializeWith<'a>(&'a Vec<RecognizingAuthorityProperty>);
621 impl<'a> Serialize for SerializeWith<'a> {
622 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
623 where
624 S: Serializer,
625 {
626 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
627 self.0, serializer,
628 )
629 }
630 }
631 &SerializeWith(&self.r#recognizing_authority)
632 })?;
633 } else {
634 serialize_struct.skip_field("recognizingAuthority")?;
635 }
636 if !Vec::is_empty(&self.r#relevant_specialty) {
637 serialize_struct.serialize_field("relevantSpecialty", {
638 struct SerializeWith<'a>(&'a Vec<RelevantSpecialtyProperty>);
639 impl<'a> Serialize for SerializeWith<'a> {
640 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
641 where
642 S: Serializer,
643 {
644 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
645 self.0, serializer,
646 )
647 }
648 }
649 &SerializeWith(&self.r#relevant_specialty)
650 })?;
651 } else {
652 serialize_struct.skip_field("relevantSpecialty")?;
653 }
654 if !Vec::is_empty(&self.r#study) {
655 serialize_struct.serialize_field("study", {
656 struct SerializeWith<'a>(&'a Vec<StudyProperty>);
657 impl<'a> Serialize for SerializeWith<'a> {
658 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
659 where
660 S: Serializer,
661 {
662 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
663 self.0, serializer,
664 )
665 }
666 }
667 &SerializeWith(&self.r#study)
668 })?;
669 } else {
670 serialize_struct.skip_field("study")?;
671 }
672 if !Vec::is_empty(&self.r#additional_type) {
673 serialize_struct.serialize_field("additionalType", {
674 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
675 impl<'a> Serialize for SerializeWith<'a> {
676 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
677 where
678 S: Serializer,
679 {
680 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
681 self.0, serializer,
682 )
683 }
684 }
685 &SerializeWith(&self.r#additional_type)
686 })?;
687 } else {
688 serialize_struct.skip_field("additionalType")?;
689 }
690 if !Vec::is_empty(&self.r#alternate_name) {
691 serialize_struct.serialize_field("alternateName", {
692 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
693 impl<'a> Serialize for SerializeWith<'a> {
694 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
695 where
696 S: Serializer,
697 {
698 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
699 self.0, serializer,
700 )
701 }
702 }
703 &SerializeWith(&self.r#alternate_name)
704 })?;
705 } else {
706 serialize_struct.skip_field("alternateName")?;
707 }
708 if !Vec::is_empty(&self.r#description) {
709 serialize_struct.serialize_field("description", {
710 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
711 impl<'a> Serialize for SerializeWith<'a> {
712 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
713 where
714 S: Serializer,
715 {
716 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
717 self.0, serializer,
718 )
719 }
720 }
721 &SerializeWith(&self.r#description)
722 })?;
723 } else {
724 serialize_struct.skip_field("description")?;
725 }
726 if !Vec::is_empty(&self.r#disambiguating_description) {
727 serialize_struct.serialize_field("disambiguatingDescription", {
728 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
729 impl<'a> Serialize for SerializeWith<'a> {
730 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
731 where
732 S: Serializer,
733 {
734 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
735 self.0, serializer,
736 )
737 }
738 }
739 &SerializeWith(&self.r#disambiguating_description)
740 })?;
741 } else {
742 serialize_struct.skip_field("disambiguatingDescription")?;
743 }
744 if !Vec::is_empty(&self.r#identifier) {
745 serialize_struct.serialize_field("identifier", {
746 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
747 impl<'a> Serialize for SerializeWith<'a> {
748 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
749 where
750 S: Serializer,
751 {
752 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
753 self.0, serializer,
754 )
755 }
756 }
757 &SerializeWith(&self.r#identifier)
758 })?;
759 } else {
760 serialize_struct.skip_field("identifier")?;
761 }
762 if !Vec::is_empty(&self.r#image) {
763 serialize_struct.serialize_field("image", {
764 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
765 impl<'a> Serialize for SerializeWith<'a> {
766 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
767 where
768 S: Serializer,
769 {
770 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
771 self.0, serializer,
772 )
773 }
774 }
775 &SerializeWith(&self.r#image)
776 })?;
777 } else {
778 serialize_struct.skip_field("image")?;
779 }
780 if !Vec::is_empty(&self.r#main_entity_of_page) {
781 serialize_struct.serialize_field("mainEntityOfPage", {
782 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
783 impl<'a> Serialize for SerializeWith<'a> {
784 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
785 where
786 S: Serializer,
787 {
788 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
789 self.0, serializer,
790 )
791 }
792 }
793 &SerializeWith(&self.r#main_entity_of_page)
794 })?;
795 } else {
796 serialize_struct.skip_field("mainEntityOfPage")?;
797 }
798 if !Vec::is_empty(&self.r#name) {
799 serialize_struct.serialize_field("name", {
800 struct SerializeWith<'a>(&'a Vec<NameProperty>);
801 impl<'a> Serialize for SerializeWith<'a> {
802 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
803 where
804 S: Serializer,
805 {
806 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
807 self.0, serializer,
808 )
809 }
810 }
811 &SerializeWith(&self.r#name)
812 })?;
813 } else {
814 serialize_struct.skip_field("name")?;
815 }
816 if !Vec::is_empty(&self.r#potential_action) {
817 serialize_struct.serialize_field("potentialAction", {
818 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
819 impl<'a> Serialize for SerializeWith<'a> {
820 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
821 where
822 S: Serializer,
823 {
824 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
825 self.0, serializer,
826 )
827 }
828 }
829 &SerializeWith(&self.r#potential_action)
830 })?;
831 } else {
832 serialize_struct.skip_field("potentialAction")?;
833 }
834 if !Vec::is_empty(&self.r#same_as) {
835 serialize_struct.serialize_field("sameAs", {
836 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
837 impl<'a> Serialize for SerializeWith<'a> {
838 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
839 where
840 S: Serializer,
841 {
842 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
843 self.0, serializer,
844 )
845 }
846 }
847 &SerializeWith(&self.r#same_as)
848 })?;
849 } else {
850 serialize_struct.skip_field("sameAs")?;
851 }
852 if !Vec::is_empty(&self.r#subject_of) {
853 serialize_struct.serialize_field("subjectOf", {
854 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
855 impl<'a> Serialize for SerializeWith<'a> {
856 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
857 where
858 S: Serializer,
859 {
860 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
861 self.0, serializer,
862 )
863 }
864 }
865 &SerializeWith(&self.r#subject_of)
866 })?;
867 } else {
868 serialize_struct.skip_field("subjectOf")?;
869 }
870 if !Vec::is_empty(&self.r#url) {
871 serialize_struct.serialize_field("url", {
872 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
873 impl<'a> Serialize for SerializeWith<'a> {
874 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
875 where
876 S: Serializer,
877 {
878 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
879 self.0, serializer,
880 )
881 }
882 }
883 &SerializeWith(&self.r#url)
884 })?;
885 } else {
886 serialize_struct.skip_field("url")?;
887 }
888 serialize_struct.end()
889 }
890 }
891 impl<'de> Deserialize<'de> for LymphaticVessel {
892 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
893 where
894 D: Deserializer<'de>,
895 {
896 enum Field {
897 OriginatesFrom,
898 RegionDrained,
899 RunsTo,
900 AssociatedPathophysiology,
901 BodyLocation,
902 ConnectedTo,
903 Diagram,
904 PartOfSystem,
905 RelatedCondition,
906 RelatedTherapy,
907 SubStructure,
908 Code,
909 Funding,
910 Guideline,
911 LegalStatus,
912 MedicineSystem,
913 RecognizingAuthority,
914 RelevantSpecialty,
915 Study,
916 AdditionalType,
917 AlternateName,
918 Description,
919 DisambiguatingDescription,
920 Identifier,
921 Image,
922 MainEntityOfPage,
923 Name,
924 PotentialAction,
925 SameAs,
926 SubjectOf,
927 Url,
928 Ignore,
929 }
930 struct FieldVisitor;
931 impl<'de> Visitor<'de> for FieldVisitor {
932 type Value = Field;
933 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
934 formatter.write_str("field identifier")
935 }
936 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
937 where
938 E: de::Error,
939 {
940 match value {
941 "originatesFrom" => Ok(Field::OriginatesFrom),
942 "regionDrained" => Ok(Field::RegionDrained),
943 "runsTo" => Ok(Field::RunsTo),
944 "associatedPathophysiology" => Ok(Field::AssociatedPathophysiology),
945 "bodyLocation" => Ok(Field::BodyLocation),
946 "connectedTo" => Ok(Field::ConnectedTo),
947 "diagram" => Ok(Field::Diagram),
948 "partOfSystem" => Ok(Field::PartOfSystem),
949 "relatedCondition" => Ok(Field::RelatedCondition),
950 "relatedTherapy" => Ok(Field::RelatedTherapy),
951 "subStructure" => Ok(Field::SubStructure),
952 "code" => Ok(Field::Code),
953 "funding" => Ok(Field::Funding),
954 "guideline" => Ok(Field::Guideline),
955 "legalStatus" => Ok(Field::LegalStatus),
956 "medicineSystem" => Ok(Field::MedicineSystem),
957 "recognizingAuthority" => Ok(Field::RecognizingAuthority),
958 "relevantSpecialty" => Ok(Field::RelevantSpecialty),
959 "study" => Ok(Field::Study),
960 "additionalType" => Ok(Field::AdditionalType),
961 "alternateName" => Ok(Field::AlternateName),
962 "description" => Ok(Field::Description),
963 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
964 "identifier" => Ok(Field::Identifier),
965 "image" => Ok(Field::Image),
966 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
967 "name" => Ok(Field::Name),
968 "potentialAction" => Ok(Field::PotentialAction),
969 "sameAs" => Ok(Field::SameAs),
970 "subjectOf" => Ok(Field::SubjectOf),
971 "url" => Ok(Field::Url),
972 "id" | "type" => Ok(Field::Ignore),
973 _ => Err(de::Error::unknown_field(value, FIELDS)),
974 }
975 }
976 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
977 where
978 E: de::Error,
979 {
980 match value {
981 b"originatesFrom" => Ok(Field::OriginatesFrom),
982 b"regionDrained" => Ok(Field::RegionDrained),
983 b"runsTo" => Ok(Field::RunsTo),
984 b"associatedPathophysiology" => Ok(Field::AssociatedPathophysiology),
985 b"bodyLocation" => Ok(Field::BodyLocation),
986 b"connectedTo" => Ok(Field::ConnectedTo),
987 b"diagram" => Ok(Field::Diagram),
988 b"partOfSystem" => Ok(Field::PartOfSystem),
989 b"relatedCondition" => Ok(Field::RelatedCondition),
990 b"relatedTherapy" => Ok(Field::RelatedTherapy),
991 b"subStructure" => Ok(Field::SubStructure),
992 b"code" => Ok(Field::Code),
993 b"funding" => Ok(Field::Funding),
994 b"guideline" => Ok(Field::Guideline),
995 b"legalStatus" => Ok(Field::LegalStatus),
996 b"medicineSystem" => Ok(Field::MedicineSystem),
997 b"recognizingAuthority" => Ok(Field::RecognizingAuthority),
998 b"relevantSpecialty" => Ok(Field::RelevantSpecialty),
999 b"study" => Ok(Field::Study),
1000 b"additionalType" => Ok(Field::AdditionalType),
1001 b"alternateName" => Ok(Field::AlternateName),
1002 b"description" => Ok(Field::Description),
1003 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
1004 b"identifier" => Ok(Field::Identifier),
1005 b"image" => Ok(Field::Image),
1006 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
1007 b"name" => Ok(Field::Name),
1008 b"potentialAction" => Ok(Field::PotentialAction),
1009 b"sameAs" => Ok(Field::SameAs),
1010 b"subjectOf" => Ok(Field::SubjectOf),
1011 b"url" => Ok(Field::Url),
1012 b"id" | b"type" => Ok(Field::Ignore),
1013 _ => {
1014 let value = &String::from_utf8_lossy(value);
1015 Err(de::Error::unknown_field(value, FIELDS))
1016 }
1017 }
1018 }
1019 }
1020 impl<'de> Deserialize<'de> for Field {
1021 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1022 where
1023 D: Deserializer<'de>,
1024 {
1025 deserializer.deserialize_identifier(FieldVisitor)
1026 }
1027 }
1028 struct ClassVisitor;
1029 impl<'de> Visitor<'de> for ClassVisitor {
1030 type Value = LymphaticVessel;
1031 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
1032 formatter.write_str("schema.org schema LymphaticVessel")
1033 }
1034 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1035 where
1036 A: de::MapAccess<'de>,
1037 {
1038 let mut r#originates_from_property = None;
1039 let mut r#region_drained_property = None;
1040 let mut r#runs_to_property = None;
1041 let mut r#associated_pathophysiology_property = None;
1042 let mut r#body_location_property = None;
1043 let mut r#connected_to_property = None;
1044 let mut r#diagram_property = None;
1045 let mut r#part_of_system_property = None;
1046 let mut r#related_condition_property = None;
1047 let mut r#related_therapy_property = None;
1048 let mut r#sub_structure_property = None;
1049 let mut r#code_property = None;
1050 let mut r#funding_property = None;
1051 let mut r#guideline_property = None;
1052 let mut r#legal_status_property = None;
1053 let mut r#medicine_system_property = None;
1054 let mut r#recognizing_authority_property = None;
1055 let mut r#relevant_specialty_property = None;
1056 let mut r#study_property = None;
1057 let mut r#additional_type_property = None;
1058 let mut r#alternate_name_property = None;
1059 let mut r#description_property = None;
1060 let mut r#disambiguating_description_property = None;
1061 let mut r#identifier_property = None;
1062 let mut r#image_property = None;
1063 let mut r#main_entity_of_page_property = None;
1064 let mut r#name_property = None;
1065 let mut r#potential_action_property = None;
1066 let mut r#same_as_property = None;
1067 let mut r#subject_of_property = None;
1068 let mut r#url_property = None;
1069 while let Some(key) = map.next_key::<Field>()? {
1070 match key {
1071 Field::OriginatesFrom => {
1072 if r#originates_from_property.is_some() {
1073 return Err(<A::Error as de::Error>::duplicate_field(
1074 "originatesFrom",
1075 ));
1076 }
1077 r#originates_from_property = Some({
1078 struct DeserializeWith(Vec<OriginatesFromProperty>);
1079 impl<'de> Deserialize<'de> for DeserializeWith {
1080 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1081 where
1082 D: Deserializer<'de>,
1083 {
1084 Ok(DeserializeWith(serde_with::As::<
1085 serde_with::OneOrMany<serde_with::Same>,
1086 >::deserialize(deserializer)?))
1087 }
1088 }
1089 match map.next_value::<DeserializeWith>() {
1090 Ok(deserialize_with) => deserialize_with.0,
1091 Err(err) => {
1092 return Err(err);
1093 }
1094 }
1095 });
1096 }
1097 Field::RegionDrained => {
1098 if r#region_drained_property.is_some() {
1099 return Err(<A::Error as de::Error>::duplicate_field(
1100 "regionDrained",
1101 ));
1102 }
1103 r#region_drained_property = Some({
1104 struct DeserializeWith(Vec<RegionDrainedProperty>);
1105 impl<'de> Deserialize<'de> for DeserializeWith {
1106 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1107 where
1108 D: Deserializer<'de>,
1109 {
1110 Ok(DeserializeWith(serde_with::As::<
1111 serde_with::OneOrMany<serde_with::Same>,
1112 >::deserialize(deserializer)?))
1113 }
1114 }
1115 match map.next_value::<DeserializeWith>() {
1116 Ok(deserialize_with) => deserialize_with.0,
1117 Err(err) => {
1118 return Err(err);
1119 }
1120 }
1121 });
1122 }
1123 Field::RunsTo => {
1124 if r#runs_to_property.is_some() {
1125 return Err(<A::Error as de::Error>::duplicate_field("runsTo"));
1126 }
1127 r#runs_to_property = Some({
1128 struct DeserializeWith(Vec<RunsToProperty>);
1129 impl<'de> Deserialize<'de> for DeserializeWith {
1130 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1131 where
1132 D: Deserializer<'de>,
1133 {
1134 Ok(DeserializeWith(serde_with::As::<
1135 serde_with::OneOrMany<serde_with::Same>,
1136 >::deserialize(deserializer)?))
1137 }
1138 }
1139 match map.next_value::<DeserializeWith>() {
1140 Ok(deserialize_with) => deserialize_with.0,
1141 Err(err) => {
1142 return Err(err);
1143 }
1144 }
1145 });
1146 }
1147 Field::AssociatedPathophysiology => {
1148 if r#associated_pathophysiology_property.is_some() {
1149 return Err(<A::Error as de::Error>::duplicate_field(
1150 "associatedPathophysiology",
1151 ));
1152 }
1153 r#associated_pathophysiology_property = Some({
1154 struct DeserializeWith(Vec<AssociatedPathophysiologyProperty>);
1155 impl<'de> Deserialize<'de> for DeserializeWith {
1156 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1157 where
1158 D: Deserializer<'de>,
1159 {
1160 Ok(DeserializeWith(serde_with::As::<
1161 serde_with::OneOrMany<serde_with::Same>,
1162 >::deserialize(deserializer)?))
1163 }
1164 }
1165 match map.next_value::<DeserializeWith>() {
1166 Ok(deserialize_with) => deserialize_with.0,
1167 Err(err) => {
1168 return Err(err);
1169 }
1170 }
1171 });
1172 }
1173 Field::BodyLocation => {
1174 if r#body_location_property.is_some() {
1175 return Err(<A::Error as de::Error>::duplicate_field(
1176 "bodyLocation",
1177 ));
1178 }
1179 r#body_location_property = Some({
1180 struct DeserializeWith(Vec<BodyLocationProperty>);
1181 impl<'de> Deserialize<'de> for DeserializeWith {
1182 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1183 where
1184 D: Deserializer<'de>,
1185 {
1186 Ok(DeserializeWith(serde_with::As::<
1187 serde_with::OneOrMany<serde_with::Same>,
1188 >::deserialize(deserializer)?))
1189 }
1190 }
1191 match map.next_value::<DeserializeWith>() {
1192 Ok(deserialize_with) => deserialize_with.0,
1193 Err(err) => {
1194 return Err(err);
1195 }
1196 }
1197 });
1198 }
1199 Field::ConnectedTo => {
1200 if r#connected_to_property.is_some() {
1201 return Err(<A::Error as de::Error>::duplicate_field(
1202 "connectedTo",
1203 ));
1204 }
1205 r#connected_to_property = Some({
1206 struct DeserializeWith(Vec<ConnectedToProperty>);
1207 impl<'de> Deserialize<'de> for DeserializeWith {
1208 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1209 where
1210 D: Deserializer<'de>,
1211 {
1212 Ok(DeserializeWith(serde_with::As::<
1213 serde_with::OneOrMany<serde_with::Same>,
1214 >::deserialize(deserializer)?))
1215 }
1216 }
1217 match map.next_value::<DeserializeWith>() {
1218 Ok(deserialize_with) => deserialize_with.0,
1219 Err(err) => {
1220 return Err(err);
1221 }
1222 }
1223 });
1224 }
1225 Field::Diagram => {
1226 if r#diagram_property.is_some() {
1227 return Err(<A::Error as de::Error>::duplicate_field(
1228 "diagram",
1229 ));
1230 }
1231 r#diagram_property = Some({
1232 struct DeserializeWith(Vec<DiagramProperty>);
1233 impl<'de> Deserialize<'de> for DeserializeWith {
1234 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1235 where
1236 D: Deserializer<'de>,
1237 {
1238 Ok(DeserializeWith(serde_with::As::<
1239 serde_with::OneOrMany<serde_with::Same>,
1240 >::deserialize(deserializer)?))
1241 }
1242 }
1243 match map.next_value::<DeserializeWith>() {
1244 Ok(deserialize_with) => deserialize_with.0,
1245 Err(err) => {
1246 return Err(err);
1247 }
1248 }
1249 });
1250 }
1251 Field::PartOfSystem => {
1252 if r#part_of_system_property.is_some() {
1253 return Err(<A::Error as de::Error>::duplicate_field(
1254 "partOfSystem",
1255 ));
1256 }
1257 r#part_of_system_property = Some({
1258 struct DeserializeWith(Vec<PartOfSystemProperty>);
1259 impl<'de> Deserialize<'de> for DeserializeWith {
1260 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1261 where
1262 D: Deserializer<'de>,
1263 {
1264 Ok(DeserializeWith(serde_with::As::<
1265 serde_with::OneOrMany<serde_with::Same>,
1266 >::deserialize(deserializer)?))
1267 }
1268 }
1269 match map.next_value::<DeserializeWith>() {
1270 Ok(deserialize_with) => deserialize_with.0,
1271 Err(err) => {
1272 return Err(err);
1273 }
1274 }
1275 });
1276 }
1277 Field::RelatedCondition => {
1278 if r#related_condition_property.is_some() {
1279 return Err(<A::Error as de::Error>::duplicate_field(
1280 "relatedCondition",
1281 ));
1282 }
1283 r#related_condition_property = Some({
1284 struct DeserializeWith(Vec<RelatedConditionProperty>);
1285 impl<'de> Deserialize<'de> for DeserializeWith {
1286 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1287 where
1288 D: Deserializer<'de>,
1289 {
1290 Ok(DeserializeWith(serde_with::As::<
1291 serde_with::OneOrMany<serde_with::Same>,
1292 >::deserialize(deserializer)?))
1293 }
1294 }
1295 match map.next_value::<DeserializeWith>() {
1296 Ok(deserialize_with) => deserialize_with.0,
1297 Err(err) => {
1298 return Err(err);
1299 }
1300 }
1301 });
1302 }
1303 Field::RelatedTherapy => {
1304 if r#related_therapy_property.is_some() {
1305 return Err(<A::Error as de::Error>::duplicate_field(
1306 "relatedTherapy",
1307 ));
1308 }
1309 r#related_therapy_property = Some({
1310 struct DeserializeWith(Vec<RelatedTherapyProperty>);
1311 impl<'de> Deserialize<'de> for DeserializeWith {
1312 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1313 where
1314 D: Deserializer<'de>,
1315 {
1316 Ok(DeserializeWith(serde_with::As::<
1317 serde_with::OneOrMany<serde_with::Same>,
1318 >::deserialize(deserializer)?))
1319 }
1320 }
1321 match map.next_value::<DeserializeWith>() {
1322 Ok(deserialize_with) => deserialize_with.0,
1323 Err(err) => {
1324 return Err(err);
1325 }
1326 }
1327 });
1328 }
1329 Field::SubStructure => {
1330 if r#sub_structure_property.is_some() {
1331 return Err(<A::Error as de::Error>::duplicate_field(
1332 "subStructure",
1333 ));
1334 }
1335 r#sub_structure_property = Some({
1336 struct DeserializeWith(Vec<SubStructureProperty>);
1337 impl<'de> Deserialize<'de> for DeserializeWith {
1338 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1339 where
1340 D: Deserializer<'de>,
1341 {
1342 Ok(DeserializeWith(serde_with::As::<
1343 serde_with::OneOrMany<serde_with::Same>,
1344 >::deserialize(deserializer)?))
1345 }
1346 }
1347 match map.next_value::<DeserializeWith>() {
1348 Ok(deserialize_with) => deserialize_with.0,
1349 Err(err) => {
1350 return Err(err);
1351 }
1352 }
1353 });
1354 }
1355 Field::Code => {
1356 if r#code_property.is_some() {
1357 return Err(<A::Error as de::Error>::duplicate_field("code"));
1358 }
1359 r#code_property = Some({
1360 struct DeserializeWith(Vec<CodeProperty>);
1361 impl<'de> Deserialize<'de> for DeserializeWith {
1362 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1363 where
1364 D: Deserializer<'de>,
1365 {
1366 Ok(DeserializeWith(serde_with::As::<
1367 serde_with::OneOrMany<serde_with::Same>,
1368 >::deserialize(deserializer)?))
1369 }
1370 }
1371 match map.next_value::<DeserializeWith>() {
1372 Ok(deserialize_with) => deserialize_with.0,
1373 Err(err) => {
1374 return Err(err);
1375 }
1376 }
1377 });
1378 }
1379 Field::Funding => {
1380 if r#funding_property.is_some() {
1381 return Err(<A::Error as de::Error>::duplicate_field(
1382 "funding",
1383 ));
1384 }
1385 r#funding_property = Some({
1386 struct DeserializeWith(Vec<FundingProperty>);
1387 impl<'de> Deserialize<'de> for DeserializeWith {
1388 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1389 where
1390 D: Deserializer<'de>,
1391 {
1392 Ok(DeserializeWith(serde_with::As::<
1393 serde_with::OneOrMany<serde_with::Same>,
1394 >::deserialize(deserializer)?))
1395 }
1396 }
1397 match map.next_value::<DeserializeWith>() {
1398 Ok(deserialize_with) => deserialize_with.0,
1399 Err(err) => {
1400 return Err(err);
1401 }
1402 }
1403 });
1404 }
1405 Field::Guideline => {
1406 if r#guideline_property.is_some() {
1407 return Err(<A::Error as de::Error>::duplicate_field(
1408 "guideline",
1409 ));
1410 }
1411 r#guideline_property = Some({
1412 struct DeserializeWith(Vec<GuidelineProperty>);
1413 impl<'de> Deserialize<'de> for DeserializeWith {
1414 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1415 where
1416 D: Deserializer<'de>,
1417 {
1418 Ok(DeserializeWith(serde_with::As::<
1419 serde_with::OneOrMany<serde_with::Same>,
1420 >::deserialize(deserializer)?))
1421 }
1422 }
1423 match map.next_value::<DeserializeWith>() {
1424 Ok(deserialize_with) => deserialize_with.0,
1425 Err(err) => {
1426 return Err(err);
1427 }
1428 }
1429 });
1430 }
1431 Field::LegalStatus => {
1432 if r#legal_status_property.is_some() {
1433 return Err(<A::Error as de::Error>::duplicate_field(
1434 "legalStatus",
1435 ));
1436 }
1437 r#legal_status_property = Some({
1438 struct DeserializeWith(Vec<LegalStatusProperty>);
1439 impl<'de> Deserialize<'de> for DeserializeWith {
1440 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1441 where
1442 D: Deserializer<'de>,
1443 {
1444 Ok(DeserializeWith(serde_with::As::<
1445 serde_with::OneOrMany<serde_with::Same>,
1446 >::deserialize(deserializer)?))
1447 }
1448 }
1449 match map.next_value::<DeserializeWith>() {
1450 Ok(deserialize_with) => deserialize_with.0,
1451 Err(err) => {
1452 return Err(err);
1453 }
1454 }
1455 });
1456 }
1457 Field::MedicineSystem => {
1458 if r#medicine_system_property.is_some() {
1459 return Err(<A::Error as de::Error>::duplicate_field(
1460 "medicineSystem",
1461 ));
1462 }
1463 r#medicine_system_property = Some({
1464 struct DeserializeWith(Vec<MedicineSystemProperty>);
1465 impl<'de> Deserialize<'de> for DeserializeWith {
1466 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1467 where
1468 D: Deserializer<'de>,
1469 {
1470 Ok(DeserializeWith(serde_with::As::<
1471 serde_with::OneOrMany<serde_with::Same>,
1472 >::deserialize(deserializer)?))
1473 }
1474 }
1475 match map.next_value::<DeserializeWith>() {
1476 Ok(deserialize_with) => deserialize_with.0,
1477 Err(err) => {
1478 return Err(err);
1479 }
1480 }
1481 });
1482 }
1483 Field::RecognizingAuthority => {
1484 if r#recognizing_authority_property.is_some() {
1485 return Err(<A::Error as de::Error>::duplicate_field(
1486 "recognizingAuthority",
1487 ));
1488 }
1489 r#recognizing_authority_property = Some({
1490 struct DeserializeWith(Vec<RecognizingAuthorityProperty>);
1491 impl<'de> Deserialize<'de> for DeserializeWith {
1492 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1493 where
1494 D: Deserializer<'de>,
1495 {
1496 Ok(DeserializeWith(serde_with::As::<
1497 serde_with::OneOrMany<serde_with::Same>,
1498 >::deserialize(deserializer)?))
1499 }
1500 }
1501 match map.next_value::<DeserializeWith>() {
1502 Ok(deserialize_with) => deserialize_with.0,
1503 Err(err) => {
1504 return Err(err);
1505 }
1506 }
1507 });
1508 }
1509 Field::RelevantSpecialty => {
1510 if r#relevant_specialty_property.is_some() {
1511 return Err(<A::Error as de::Error>::duplicate_field(
1512 "relevantSpecialty",
1513 ));
1514 }
1515 r#relevant_specialty_property = Some({
1516 struct DeserializeWith(Vec<RelevantSpecialtyProperty>);
1517 impl<'de> Deserialize<'de> for DeserializeWith {
1518 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1519 where
1520 D: Deserializer<'de>,
1521 {
1522 Ok(DeserializeWith(serde_with::As::<
1523 serde_with::OneOrMany<serde_with::Same>,
1524 >::deserialize(deserializer)?))
1525 }
1526 }
1527 match map.next_value::<DeserializeWith>() {
1528 Ok(deserialize_with) => deserialize_with.0,
1529 Err(err) => {
1530 return Err(err);
1531 }
1532 }
1533 });
1534 }
1535 Field::Study => {
1536 if r#study_property.is_some() {
1537 return Err(<A::Error as de::Error>::duplicate_field("study"));
1538 }
1539 r#study_property = Some({
1540 struct DeserializeWith(Vec<StudyProperty>);
1541 impl<'de> Deserialize<'de> for DeserializeWith {
1542 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1543 where
1544 D: Deserializer<'de>,
1545 {
1546 Ok(DeserializeWith(serde_with::As::<
1547 serde_with::OneOrMany<serde_with::Same>,
1548 >::deserialize(deserializer)?))
1549 }
1550 }
1551 match map.next_value::<DeserializeWith>() {
1552 Ok(deserialize_with) => deserialize_with.0,
1553 Err(err) => {
1554 return Err(err);
1555 }
1556 }
1557 });
1558 }
1559 Field::AdditionalType => {
1560 if r#additional_type_property.is_some() {
1561 return Err(<A::Error as de::Error>::duplicate_field(
1562 "additionalType",
1563 ));
1564 }
1565 r#additional_type_property = Some({
1566 struct DeserializeWith(Vec<AdditionalTypeProperty>);
1567 impl<'de> Deserialize<'de> for DeserializeWith {
1568 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1569 where
1570 D: Deserializer<'de>,
1571 {
1572 Ok(DeserializeWith(serde_with::As::<
1573 serde_with::OneOrMany<serde_with::Same>,
1574 >::deserialize(deserializer)?))
1575 }
1576 }
1577 match map.next_value::<DeserializeWith>() {
1578 Ok(deserialize_with) => deserialize_with.0,
1579 Err(err) => {
1580 return Err(err);
1581 }
1582 }
1583 });
1584 }
1585 Field::AlternateName => {
1586 if r#alternate_name_property.is_some() {
1587 return Err(<A::Error as de::Error>::duplicate_field(
1588 "alternateName",
1589 ));
1590 }
1591 r#alternate_name_property = Some({
1592 struct DeserializeWith(Vec<AlternateNameProperty>);
1593 impl<'de> Deserialize<'de> for DeserializeWith {
1594 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1595 where
1596 D: Deserializer<'de>,
1597 {
1598 Ok(DeserializeWith(serde_with::As::<
1599 serde_with::OneOrMany<serde_with::Same>,
1600 >::deserialize(deserializer)?))
1601 }
1602 }
1603 match map.next_value::<DeserializeWith>() {
1604 Ok(deserialize_with) => deserialize_with.0,
1605 Err(err) => {
1606 return Err(err);
1607 }
1608 }
1609 });
1610 }
1611 Field::Description => {
1612 if r#description_property.is_some() {
1613 return Err(<A::Error as de::Error>::duplicate_field(
1614 "description",
1615 ));
1616 }
1617 r#description_property = Some({
1618 struct DeserializeWith(Vec<DescriptionProperty>);
1619 impl<'de> Deserialize<'de> for DeserializeWith {
1620 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1621 where
1622 D: Deserializer<'de>,
1623 {
1624 Ok(DeserializeWith(serde_with::As::<
1625 serde_with::OneOrMany<serde_with::Same>,
1626 >::deserialize(deserializer)?))
1627 }
1628 }
1629 match map.next_value::<DeserializeWith>() {
1630 Ok(deserialize_with) => deserialize_with.0,
1631 Err(err) => {
1632 return Err(err);
1633 }
1634 }
1635 });
1636 }
1637 Field::DisambiguatingDescription => {
1638 if r#disambiguating_description_property.is_some() {
1639 return Err(<A::Error as de::Error>::duplicate_field(
1640 "disambiguatingDescription",
1641 ));
1642 }
1643 r#disambiguating_description_property = Some({
1644 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1645 impl<'de> Deserialize<'de> for DeserializeWith {
1646 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1647 where
1648 D: Deserializer<'de>,
1649 {
1650 Ok(DeserializeWith(serde_with::As::<
1651 serde_with::OneOrMany<serde_with::Same>,
1652 >::deserialize(deserializer)?))
1653 }
1654 }
1655 match map.next_value::<DeserializeWith>() {
1656 Ok(deserialize_with) => deserialize_with.0,
1657 Err(err) => {
1658 return Err(err);
1659 }
1660 }
1661 });
1662 }
1663 Field::Identifier => {
1664 if r#identifier_property.is_some() {
1665 return Err(<A::Error as de::Error>::duplicate_field(
1666 "identifier",
1667 ));
1668 }
1669 r#identifier_property = Some({
1670 struct DeserializeWith(Vec<IdentifierProperty>);
1671 impl<'de> Deserialize<'de> for DeserializeWith {
1672 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1673 where
1674 D: Deserializer<'de>,
1675 {
1676 Ok(DeserializeWith(serde_with::As::<
1677 serde_with::OneOrMany<serde_with::Same>,
1678 >::deserialize(deserializer)?))
1679 }
1680 }
1681 match map.next_value::<DeserializeWith>() {
1682 Ok(deserialize_with) => deserialize_with.0,
1683 Err(err) => {
1684 return Err(err);
1685 }
1686 }
1687 });
1688 }
1689 Field::Image => {
1690 if r#image_property.is_some() {
1691 return Err(<A::Error as de::Error>::duplicate_field("image"));
1692 }
1693 r#image_property = Some({
1694 struct DeserializeWith(Vec<ImageProperty>);
1695 impl<'de> Deserialize<'de> for DeserializeWith {
1696 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1697 where
1698 D: Deserializer<'de>,
1699 {
1700 Ok(DeserializeWith(serde_with::As::<
1701 serde_with::OneOrMany<serde_with::Same>,
1702 >::deserialize(deserializer)?))
1703 }
1704 }
1705 match map.next_value::<DeserializeWith>() {
1706 Ok(deserialize_with) => deserialize_with.0,
1707 Err(err) => {
1708 return Err(err);
1709 }
1710 }
1711 });
1712 }
1713 Field::MainEntityOfPage => {
1714 if r#main_entity_of_page_property.is_some() {
1715 return Err(<A::Error as de::Error>::duplicate_field(
1716 "mainEntityOfPage",
1717 ));
1718 }
1719 r#main_entity_of_page_property = Some({
1720 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1721 impl<'de> Deserialize<'de> for DeserializeWith {
1722 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1723 where
1724 D: Deserializer<'de>,
1725 {
1726 Ok(DeserializeWith(serde_with::As::<
1727 serde_with::OneOrMany<serde_with::Same>,
1728 >::deserialize(deserializer)?))
1729 }
1730 }
1731 match map.next_value::<DeserializeWith>() {
1732 Ok(deserialize_with) => deserialize_with.0,
1733 Err(err) => {
1734 return Err(err);
1735 }
1736 }
1737 });
1738 }
1739 Field::Name => {
1740 if r#name_property.is_some() {
1741 return Err(<A::Error as de::Error>::duplicate_field("name"));
1742 }
1743 r#name_property = Some({
1744 struct DeserializeWith(Vec<NameProperty>);
1745 impl<'de> Deserialize<'de> for DeserializeWith {
1746 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1747 where
1748 D: Deserializer<'de>,
1749 {
1750 Ok(DeserializeWith(serde_with::As::<
1751 serde_with::OneOrMany<serde_with::Same>,
1752 >::deserialize(deserializer)?))
1753 }
1754 }
1755 match map.next_value::<DeserializeWith>() {
1756 Ok(deserialize_with) => deserialize_with.0,
1757 Err(err) => {
1758 return Err(err);
1759 }
1760 }
1761 });
1762 }
1763 Field::PotentialAction => {
1764 if r#potential_action_property.is_some() {
1765 return Err(<A::Error as de::Error>::duplicate_field(
1766 "potentialAction",
1767 ));
1768 }
1769 r#potential_action_property = Some({
1770 struct DeserializeWith(Vec<PotentialActionProperty>);
1771 impl<'de> Deserialize<'de> for DeserializeWith {
1772 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1773 where
1774 D: Deserializer<'de>,
1775 {
1776 Ok(DeserializeWith(serde_with::As::<
1777 serde_with::OneOrMany<serde_with::Same>,
1778 >::deserialize(deserializer)?))
1779 }
1780 }
1781 match map.next_value::<DeserializeWith>() {
1782 Ok(deserialize_with) => deserialize_with.0,
1783 Err(err) => {
1784 return Err(err);
1785 }
1786 }
1787 });
1788 }
1789 Field::SameAs => {
1790 if r#same_as_property.is_some() {
1791 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1792 }
1793 r#same_as_property = Some({
1794 struct DeserializeWith(Vec<SameAsProperty>);
1795 impl<'de> Deserialize<'de> for DeserializeWith {
1796 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1797 where
1798 D: Deserializer<'de>,
1799 {
1800 Ok(DeserializeWith(serde_with::As::<
1801 serde_with::OneOrMany<serde_with::Same>,
1802 >::deserialize(deserializer)?))
1803 }
1804 }
1805 match map.next_value::<DeserializeWith>() {
1806 Ok(deserialize_with) => deserialize_with.0,
1807 Err(err) => {
1808 return Err(err);
1809 }
1810 }
1811 });
1812 }
1813 Field::SubjectOf => {
1814 if r#subject_of_property.is_some() {
1815 return Err(<A::Error as de::Error>::duplicate_field(
1816 "subjectOf",
1817 ));
1818 }
1819 r#subject_of_property = Some({
1820 struct DeserializeWith(Vec<SubjectOfProperty>);
1821 impl<'de> Deserialize<'de> for DeserializeWith {
1822 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1823 where
1824 D: Deserializer<'de>,
1825 {
1826 Ok(DeserializeWith(serde_with::As::<
1827 serde_with::OneOrMany<serde_with::Same>,
1828 >::deserialize(deserializer)?))
1829 }
1830 }
1831 match map.next_value::<DeserializeWith>() {
1832 Ok(deserialize_with) => deserialize_with.0,
1833 Err(err) => {
1834 return Err(err);
1835 }
1836 }
1837 });
1838 }
1839 Field::Url => {
1840 if r#url_property.is_some() {
1841 return Err(<A::Error as de::Error>::duplicate_field("url"));
1842 }
1843 r#url_property = Some({
1844 struct DeserializeWith(Vec<UrlProperty>);
1845 impl<'de> Deserialize<'de> for DeserializeWith {
1846 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1847 where
1848 D: Deserializer<'de>,
1849 {
1850 Ok(DeserializeWith(serde_with::As::<
1851 serde_with::OneOrMany<serde_with::Same>,
1852 >::deserialize(deserializer)?))
1853 }
1854 }
1855 match map.next_value::<DeserializeWith>() {
1856 Ok(deserialize_with) => deserialize_with.0,
1857 Err(err) => {
1858 return Err(err);
1859 }
1860 }
1861 });
1862 }
1863 Field::Ignore => {
1864 let _ = map.next_value::<de::IgnoredAny>()?;
1865 }
1866 }
1867 }
1868 Ok(LymphaticVessel {
1869 r#originates_from: r#originates_from_property.unwrap_or_default(),
1870 r#region_drained: r#region_drained_property.unwrap_or_default(),
1871 r#runs_to: r#runs_to_property.unwrap_or_default(),
1872 r#associated_pathophysiology: r#associated_pathophysiology_property
1873 .unwrap_or_default(),
1874 r#body_location: r#body_location_property.unwrap_or_default(),
1875 r#connected_to: r#connected_to_property.unwrap_or_default(),
1876 r#diagram: r#diagram_property.unwrap_or_default(),
1877 r#part_of_system: r#part_of_system_property.unwrap_or_default(),
1878 r#related_condition: r#related_condition_property.unwrap_or_default(),
1879 r#related_therapy: r#related_therapy_property.unwrap_or_default(),
1880 r#sub_structure: r#sub_structure_property.unwrap_or_default(),
1881 r#code: r#code_property.unwrap_or_default(),
1882 r#funding: r#funding_property.unwrap_or_default(),
1883 r#guideline: r#guideline_property.unwrap_or_default(),
1884 r#legal_status: r#legal_status_property.unwrap_or_default(),
1885 r#medicine_system: r#medicine_system_property.unwrap_or_default(),
1886 r#recognizing_authority: r#recognizing_authority_property
1887 .unwrap_or_default(),
1888 r#relevant_specialty: r#relevant_specialty_property.unwrap_or_default(),
1889 r#study: r#study_property.unwrap_or_default(),
1890 r#additional_type: r#additional_type_property.unwrap_or_default(),
1891 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1892 r#description: r#description_property.unwrap_or_default(),
1893 r#disambiguating_description: r#disambiguating_description_property
1894 .unwrap_or_default(),
1895 r#identifier: r#identifier_property.unwrap_or_default(),
1896 r#image: r#image_property.unwrap_or_default(),
1897 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1898 r#name: r#name_property.unwrap_or_default(),
1899 r#potential_action: r#potential_action_property.unwrap_or_default(),
1900 r#same_as: r#same_as_property.unwrap_or_default(),
1901 r#subject_of: r#subject_of_property.unwrap_or_default(),
1902 r#url: r#url_property.unwrap_or_default(),
1903 })
1904 }
1905 }
1906 const FIELDS: &[&str] = &[
1907 "originatesFrom",
1908 "regionDrained",
1909 "runsTo",
1910 "associatedPathophysiology",
1911 "bodyLocation",
1912 "connectedTo",
1913 "diagram",
1914 "partOfSystem",
1915 "relatedCondition",
1916 "relatedTherapy",
1917 "subStructure",
1918 "code",
1919 "funding",
1920 "guideline",
1921 "legalStatus",
1922 "medicineSystem",
1923 "recognizingAuthority",
1924 "relevantSpecialty",
1925 "study",
1926 "additionalType",
1927 "alternateName",
1928 "description",
1929 "disambiguatingDescription",
1930 "identifier",
1931 "image",
1932 "mainEntityOfPage",
1933 "name",
1934 "potentialAction",
1935 "sameAs",
1936 "subjectOf",
1937 "url",
1938 ];
1939 deserializer.deserialize_struct("LymphaticVessel", FIELDS, ClassVisitor)
1940 }
1941 }
1942}