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