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