1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct AcceptAction {
6 pub r#action_status: Vec<ActionStatusProperty>,
8 pub r#agent: Vec<AgentProperty>,
10 pub r#end_time: Vec<EndTimeProperty>,
12 pub r#error: Vec<ErrorProperty>,
14 pub r#instrument: Vec<InstrumentProperty>,
16 pub r#location: Vec<LocationProperty>,
18 pub r#object: Vec<ObjectProperty>,
20 pub r#participant: Vec<ParticipantProperty>,
22 pub r#provider: Vec<ProviderProperty>,
24 pub r#result: Vec<ResultProperty>,
26 pub r#start_time: Vec<StartTimeProperty>,
28 pub r#target: Vec<TargetProperty>,
30 pub r#additional_type: Vec<AdditionalTypeProperty>,
32 pub r#alternate_name: Vec<AlternateNameProperty>,
34 pub r#description: Vec<DescriptionProperty>,
36 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
38 pub r#identifier: Vec<IdentifierProperty>,
40 pub r#image: Vec<ImageProperty>,
42 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
44 pub r#name: Vec<NameProperty>,
46 pub r#potential_action: Vec<PotentialActionProperty>,
48 pub r#same_as: Vec<SameAsProperty>,
50 pub r#subject_of: Vec<SubjectOfProperty>,
52 pub r#url: Vec<UrlProperty>,
54}
55pub trait AcceptActionTrait {}
57impl AcceptActionTrait for AcceptAction {}
58impl ActionTrait for AcceptAction {
59 fn get_action_status(&self) -> &[ActionStatusProperty] {
60 self.r#action_status.as_slice()
61 }
62 fn take_action_status(&mut self) -> Vec<ActionStatusProperty> {
63 std::mem::take(&mut self.r#action_status)
64 }
65 fn get_agent(&self) -> &[AgentProperty] {
66 self.r#agent.as_slice()
67 }
68 fn take_agent(&mut self) -> Vec<AgentProperty> {
69 std::mem::take(&mut self.r#agent)
70 }
71 fn get_end_time(&self) -> &[EndTimeProperty] {
72 self.r#end_time.as_slice()
73 }
74 fn take_end_time(&mut self) -> Vec<EndTimeProperty> {
75 std::mem::take(&mut self.r#end_time)
76 }
77 fn get_error(&self) -> &[ErrorProperty] {
78 self.r#error.as_slice()
79 }
80 fn take_error(&mut self) -> Vec<ErrorProperty> {
81 std::mem::take(&mut self.r#error)
82 }
83 fn get_instrument(&self) -> &[InstrumentProperty] {
84 self.r#instrument.as_slice()
85 }
86 fn take_instrument(&mut self) -> Vec<InstrumentProperty> {
87 std::mem::take(&mut self.r#instrument)
88 }
89 fn get_location(&self) -> &[LocationProperty] {
90 self.r#location.as_slice()
91 }
92 fn take_location(&mut self) -> Vec<LocationProperty> {
93 std::mem::take(&mut self.r#location)
94 }
95 fn get_object(&self) -> &[ObjectProperty] {
96 self.r#object.as_slice()
97 }
98 fn take_object(&mut self) -> Vec<ObjectProperty> {
99 std::mem::take(&mut self.r#object)
100 }
101 fn get_participant(&self) -> &[ParticipantProperty] {
102 self.r#participant.as_slice()
103 }
104 fn take_participant(&mut self) -> Vec<ParticipantProperty> {
105 std::mem::take(&mut self.r#participant)
106 }
107 fn get_provider(&self) -> &[ProviderProperty] {
108 self.r#provider.as_slice()
109 }
110 fn take_provider(&mut self) -> Vec<ProviderProperty> {
111 std::mem::take(&mut self.r#provider)
112 }
113 fn get_result(&self) -> &[ResultProperty] {
114 self.r#result.as_slice()
115 }
116 fn take_result(&mut self) -> Vec<ResultProperty> {
117 std::mem::take(&mut self.r#result)
118 }
119 fn get_start_time(&self) -> &[StartTimeProperty] {
120 self.r#start_time.as_slice()
121 }
122 fn take_start_time(&mut self) -> Vec<StartTimeProperty> {
123 std::mem::take(&mut self.r#start_time)
124 }
125 fn get_target(&self) -> &[TargetProperty] {
126 self.r#target.as_slice()
127 }
128 fn take_target(&mut self) -> Vec<TargetProperty> {
129 std::mem::take(&mut self.r#target)
130 }
131}
132impl AllocateActionTrait for AcceptAction {}
133impl OrganizeActionTrait for AcceptAction {}
134impl ThingTrait for AcceptAction {
135 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
136 self.r#additional_type.as_slice()
137 }
138 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
139 std::mem::take(&mut self.r#additional_type)
140 }
141 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
142 self.r#alternate_name.as_slice()
143 }
144 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
145 std::mem::take(&mut self.r#alternate_name)
146 }
147 fn get_description(&self) -> &[DescriptionProperty] {
148 self.r#description.as_slice()
149 }
150 fn take_description(&mut self) -> Vec<DescriptionProperty> {
151 std::mem::take(&mut self.r#description)
152 }
153 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
154 self.r#disambiguating_description.as_slice()
155 }
156 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
157 std::mem::take(&mut self.r#disambiguating_description)
158 }
159 fn get_identifier(&self) -> &[IdentifierProperty] {
160 self.r#identifier.as_slice()
161 }
162 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
163 std::mem::take(&mut self.r#identifier)
164 }
165 fn get_image(&self) -> &[ImageProperty] {
166 self.r#image.as_slice()
167 }
168 fn take_image(&mut self) -> Vec<ImageProperty> {
169 std::mem::take(&mut self.r#image)
170 }
171 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
172 self.r#main_entity_of_page.as_slice()
173 }
174 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
175 std::mem::take(&mut self.r#main_entity_of_page)
176 }
177 fn get_name(&self) -> &[NameProperty] {
178 self.r#name.as_slice()
179 }
180 fn take_name(&mut self) -> Vec<NameProperty> {
181 std::mem::take(&mut self.r#name)
182 }
183 fn get_potential_action(&self) -> &[PotentialActionProperty] {
184 self.r#potential_action.as_slice()
185 }
186 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
187 std::mem::take(&mut self.r#potential_action)
188 }
189 fn get_same_as(&self) -> &[SameAsProperty] {
190 self.r#same_as.as_slice()
191 }
192 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
193 std::mem::take(&mut self.r#same_as)
194 }
195 fn get_subject_of(&self) -> &[SubjectOfProperty] {
196 self.r#subject_of.as_slice()
197 }
198 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
199 std::mem::take(&mut self.r#subject_of)
200 }
201 fn get_url(&self) -> &[UrlProperty] {
202 self.r#url.as_slice()
203 }
204 fn take_url(&mut self) -> Vec<UrlProperty> {
205 std::mem::take(&mut self.r#url)
206 }
207}
208#[cfg(feature = "serde")]
209mod serde {
210 use std::{fmt, fmt::Formatter};
211
212 use ::serde::{
213 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
214 };
215
216 use super::*;
217 impl Serialize for AcceptAction {
218 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219 where
220 S: Serializer,
221 {
222 let len: usize = [
223 !Vec::is_empty(&self.r#action_status) as usize,
224 !Vec::is_empty(&self.r#agent) as usize,
225 !Vec::is_empty(&self.r#end_time) as usize,
226 !Vec::is_empty(&self.r#error) as usize,
227 !Vec::is_empty(&self.r#instrument) as usize,
228 !Vec::is_empty(&self.r#location) as usize,
229 !Vec::is_empty(&self.r#object) as usize,
230 !Vec::is_empty(&self.r#participant) as usize,
231 !Vec::is_empty(&self.r#provider) as usize,
232 !Vec::is_empty(&self.r#result) as usize,
233 !Vec::is_empty(&self.r#start_time) as usize,
234 !Vec::is_empty(&self.r#target) as usize,
235 !Vec::is_empty(&self.r#additional_type) as usize,
236 !Vec::is_empty(&self.r#alternate_name) as usize,
237 !Vec::is_empty(&self.r#description) as usize,
238 !Vec::is_empty(&self.r#disambiguating_description) as usize,
239 !Vec::is_empty(&self.r#identifier) as usize,
240 !Vec::is_empty(&self.r#image) as usize,
241 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
242 !Vec::is_empty(&self.r#name) as usize,
243 !Vec::is_empty(&self.r#potential_action) as usize,
244 !Vec::is_empty(&self.r#same_as) as usize,
245 !Vec::is_empty(&self.r#subject_of) as usize,
246 !Vec::is_empty(&self.r#url) as usize,
247 ]
248 .iter()
249 .sum();
250 let mut serialize_struct =
251 Serializer::serialize_struct(serializer, "AcceptAction", len)?;
252 if !Vec::is_empty(&self.r#action_status) {
253 serialize_struct.serialize_field("actionStatus", {
254 struct SerializeWith<'a>(&'a Vec<ActionStatusProperty>);
255 impl<'a> Serialize for SerializeWith<'a> {
256 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
257 where
258 S: Serializer,
259 {
260 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
261 self.0, serializer,
262 )
263 }
264 }
265 &SerializeWith(&self.r#action_status)
266 })?;
267 } else {
268 serialize_struct.skip_field("actionStatus")?;
269 }
270 if !Vec::is_empty(&self.r#agent) {
271 serialize_struct.serialize_field("agent", {
272 struct SerializeWith<'a>(&'a Vec<AgentProperty>);
273 impl<'a> Serialize for SerializeWith<'a> {
274 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
275 where
276 S: Serializer,
277 {
278 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
279 self.0, serializer,
280 )
281 }
282 }
283 &SerializeWith(&self.r#agent)
284 })?;
285 } else {
286 serialize_struct.skip_field("agent")?;
287 }
288 if !Vec::is_empty(&self.r#end_time) {
289 serialize_struct.serialize_field("endTime", {
290 struct SerializeWith<'a>(&'a Vec<EndTimeProperty>);
291 impl<'a> Serialize for SerializeWith<'a> {
292 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
293 where
294 S: Serializer,
295 {
296 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
297 self.0, serializer,
298 )
299 }
300 }
301 &SerializeWith(&self.r#end_time)
302 })?;
303 } else {
304 serialize_struct.skip_field("endTime")?;
305 }
306 if !Vec::is_empty(&self.r#error) {
307 serialize_struct.serialize_field("error", {
308 struct SerializeWith<'a>(&'a Vec<ErrorProperty>);
309 impl<'a> Serialize for SerializeWith<'a> {
310 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
311 where
312 S: Serializer,
313 {
314 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
315 self.0, serializer,
316 )
317 }
318 }
319 &SerializeWith(&self.r#error)
320 })?;
321 } else {
322 serialize_struct.skip_field("error")?;
323 }
324 if !Vec::is_empty(&self.r#instrument) {
325 serialize_struct.serialize_field("instrument", {
326 struct SerializeWith<'a>(&'a Vec<InstrumentProperty>);
327 impl<'a> Serialize for SerializeWith<'a> {
328 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
329 where
330 S: Serializer,
331 {
332 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
333 self.0, serializer,
334 )
335 }
336 }
337 &SerializeWith(&self.r#instrument)
338 })?;
339 } else {
340 serialize_struct.skip_field("instrument")?;
341 }
342 if !Vec::is_empty(&self.r#location) {
343 serialize_struct.serialize_field("location", {
344 struct SerializeWith<'a>(&'a Vec<LocationProperty>);
345 impl<'a> Serialize for SerializeWith<'a> {
346 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
347 where
348 S: Serializer,
349 {
350 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
351 self.0, serializer,
352 )
353 }
354 }
355 &SerializeWith(&self.r#location)
356 })?;
357 } else {
358 serialize_struct.skip_field("location")?;
359 }
360 if !Vec::is_empty(&self.r#object) {
361 serialize_struct.serialize_field("object", {
362 struct SerializeWith<'a>(&'a Vec<ObjectProperty>);
363 impl<'a> Serialize for SerializeWith<'a> {
364 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
365 where
366 S: Serializer,
367 {
368 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
369 self.0, serializer,
370 )
371 }
372 }
373 &SerializeWith(&self.r#object)
374 })?;
375 } else {
376 serialize_struct.skip_field("object")?;
377 }
378 if !Vec::is_empty(&self.r#participant) {
379 serialize_struct.serialize_field("participant", {
380 struct SerializeWith<'a>(&'a Vec<ParticipantProperty>);
381 impl<'a> Serialize for SerializeWith<'a> {
382 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
383 where
384 S: Serializer,
385 {
386 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
387 self.0, serializer,
388 )
389 }
390 }
391 &SerializeWith(&self.r#participant)
392 })?;
393 } else {
394 serialize_struct.skip_field("participant")?;
395 }
396 if !Vec::is_empty(&self.r#provider) {
397 serialize_struct.serialize_field("provider", {
398 struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
399 impl<'a> Serialize for SerializeWith<'a> {
400 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
401 where
402 S: Serializer,
403 {
404 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
405 self.0, serializer,
406 )
407 }
408 }
409 &SerializeWith(&self.r#provider)
410 })?;
411 } else {
412 serialize_struct.skip_field("provider")?;
413 }
414 if !Vec::is_empty(&self.r#result) {
415 serialize_struct.serialize_field("result", {
416 struct SerializeWith<'a>(&'a Vec<ResultProperty>);
417 impl<'a> Serialize for SerializeWith<'a> {
418 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
419 where
420 S: Serializer,
421 {
422 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
423 self.0, serializer,
424 )
425 }
426 }
427 &SerializeWith(&self.r#result)
428 })?;
429 } else {
430 serialize_struct.skip_field("result")?;
431 }
432 if !Vec::is_empty(&self.r#start_time) {
433 serialize_struct.serialize_field("startTime", {
434 struct SerializeWith<'a>(&'a Vec<StartTimeProperty>);
435 impl<'a> Serialize for SerializeWith<'a> {
436 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
437 where
438 S: Serializer,
439 {
440 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
441 self.0, serializer,
442 )
443 }
444 }
445 &SerializeWith(&self.r#start_time)
446 })?;
447 } else {
448 serialize_struct.skip_field("startTime")?;
449 }
450 if !Vec::is_empty(&self.r#target) {
451 serialize_struct.serialize_field("target", {
452 struct SerializeWith<'a>(&'a Vec<TargetProperty>);
453 impl<'a> Serialize for SerializeWith<'a> {
454 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
455 where
456 S: Serializer,
457 {
458 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
459 self.0, serializer,
460 )
461 }
462 }
463 &SerializeWith(&self.r#target)
464 })?;
465 } else {
466 serialize_struct.skip_field("target")?;
467 }
468 if !Vec::is_empty(&self.r#additional_type) {
469 serialize_struct.serialize_field("additionalType", {
470 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
471 impl<'a> Serialize for SerializeWith<'a> {
472 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
473 where
474 S: Serializer,
475 {
476 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
477 self.0, serializer,
478 )
479 }
480 }
481 &SerializeWith(&self.r#additional_type)
482 })?;
483 } else {
484 serialize_struct.skip_field("additionalType")?;
485 }
486 if !Vec::is_empty(&self.r#alternate_name) {
487 serialize_struct.serialize_field("alternateName", {
488 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
489 impl<'a> Serialize for SerializeWith<'a> {
490 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
491 where
492 S: Serializer,
493 {
494 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
495 self.0, serializer,
496 )
497 }
498 }
499 &SerializeWith(&self.r#alternate_name)
500 })?;
501 } else {
502 serialize_struct.skip_field("alternateName")?;
503 }
504 if !Vec::is_empty(&self.r#description) {
505 serialize_struct.serialize_field("description", {
506 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
507 impl<'a> Serialize for SerializeWith<'a> {
508 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
509 where
510 S: Serializer,
511 {
512 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
513 self.0, serializer,
514 )
515 }
516 }
517 &SerializeWith(&self.r#description)
518 })?;
519 } else {
520 serialize_struct.skip_field("description")?;
521 }
522 if !Vec::is_empty(&self.r#disambiguating_description) {
523 serialize_struct.serialize_field("disambiguatingDescription", {
524 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
525 impl<'a> Serialize for SerializeWith<'a> {
526 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
527 where
528 S: Serializer,
529 {
530 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
531 self.0, serializer,
532 )
533 }
534 }
535 &SerializeWith(&self.r#disambiguating_description)
536 })?;
537 } else {
538 serialize_struct.skip_field("disambiguatingDescription")?;
539 }
540 if !Vec::is_empty(&self.r#identifier) {
541 serialize_struct.serialize_field("identifier", {
542 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
543 impl<'a> Serialize for SerializeWith<'a> {
544 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
545 where
546 S: Serializer,
547 {
548 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
549 self.0, serializer,
550 )
551 }
552 }
553 &SerializeWith(&self.r#identifier)
554 })?;
555 } else {
556 serialize_struct.skip_field("identifier")?;
557 }
558 if !Vec::is_empty(&self.r#image) {
559 serialize_struct.serialize_field("image", {
560 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
561 impl<'a> Serialize for SerializeWith<'a> {
562 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
563 where
564 S: Serializer,
565 {
566 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
567 self.0, serializer,
568 )
569 }
570 }
571 &SerializeWith(&self.r#image)
572 })?;
573 } else {
574 serialize_struct.skip_field("image")?;
575 }
576 if !Vec::is_empty(&self.r#main_entity_of_page) {
577 serialize_struct.serialize_field("mainEntityOfPage", {
578 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
579 impl<'a> Serialize for SerializeWith<'a> {
580 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
581 where
582 S: Serializer,
583 {
584 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
585 self.0, serializer,
586 )
587 }
588 }
589 &SerializeWith(&self.r#main_entity_of_page)
590 })?;
591 } else {
592 serialize_struct.skip_field("mainEntityOfPage")?;
593 }
594 if !Vec::is_empty(&self.r#name) {
595 serialize_struct.serialize_field("name", {
596 struct SerializeWith<'a>(&'a Vec<NameProperty>);
597 impl<'a> Serialize for SerializeWith<'a> {
598 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
599 where
600 S: Serializer,
601 {
602 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
603 self.0, serializer,
604 )
605 }
606 }
607 &SerializeWith(&self.r#name)
608 })?;
609 } else {
610 serialize_struct.skip_field("name")?;
611 }
612 if !Vec::is_empty(&self.r#potential_action) {
613 serialize_struct.serialize_field("potentialAction", {
614 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
615 impl<'a> Serialize for SerializeWith<'a> {
616 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
617 where
618 S: Serializer,
619 {
620 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
621 self.0, serializer,
622 )
623 }
624 }
625 &SerializeWith(&self.r#potential_action)
626 })?;
627 } else {
628 serialize_struct.skip_field("potentialAction")?;
629 }
630 if !Vec::is_empty(&self.r#same_as) {
631 serialize_struct.serialize_field("sameAs", {
632 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
633 impl<'a> Serialize for SerializeWith<'a> {
634 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
635 where
636 S: Serializer,
637 {
638 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
639 self.0, serializer,
640 )
641 }
642 }
643 &SerializeWith(&self.r#same_as)
644 })?;
645 } else {
646 serialize_struct.skip_field("sameAs")?;
647 }
648 if !Vec::is_empty(&self.r#subject_of) {
649 serialize_struct.serialize_field("subjectOf", {
650 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
651 impl<'a> Serialize for SerializeWith<'a> {
652 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
653 where
654 S: Serializer,
655 {
656 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
657 self.0, serializer,
658 )
659 }
660 }
661 &SerializeWith(&self.r#subject_of)
662 })?;
663 } else {
664 serialize_struct.skip_field("subjectOf")?;
665 }
666 if !Vec::is_empty(&self.r#url) {
667 serialize_struct.serialize_field("url", {
668 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
669 impl<'a> Serialize for SerializeWith<'a> {
670 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
671 where
672 S: Serializer,
673 {
674 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
675 self.0, serializer,
676 )
677 }
678 }
679 &SerializeWith(&self.r#url)
680 })?;
681 } else {
682 serialize_struct.skip_field("url")?;
683 }
684 serialize_struct.end()
685 }
686 }
687 impl<'de> Deserialize<'de> for AcceptAction {
688 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
689 where
690 D: Deserializer<'de>,
691 {
692 enum Field {
693 ActionStatus,
694 Agent,
695 EndTime,
696 Error,
697 Instrument,
698 Location,
699 Object,
700 Participant,
701 Provider,
702 Result,
703 StartTime,
704 Target,
705 AdditionalType,
706 AlternateName,
707 Description,
708 DisambiguatingDescription,
709 Identifier,
710 Image,
711 MainEntityOfPage,
712 Name,
713 PotentialAction,
714 SameAs,
715 SubjectOf,
716 Url,
717 Ignore,
718 }
719 struct FieldVisitor;
720 impl<'de> Visitor<'de> for FieldVisitor {
721 type Value = Field;
722 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
723 formatter.write_str("field identifier")
724 }
725 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
726 where
727 E: de::Error,
728 {
729 match value {
730 "actionStatus" => Ok(Field::ActionStatus),
731 "agent" => Ok(Field::Agent),
732 "endTime" => Ok(Field::EndTime),
733 "error" => Ok(Field::Error),
734 "instrument" => Ok(Field::Instrument),
735 "location" => Ok(Field::Location),
736 "object" => Ok(Field::Object),
737 "participant" => Ok(Field::Participant),
738 "provider" => Ok(Field::Provider),
739 "result" => Ok(Field::Result),
740 "startTime" => Ok(Field::StartTime),
741 "target" => Ok(Field::Target),
742 "additionalType" => Ok(Field::AdditionalType),
743 "alternateName" => Ok(Field::AlternateName),
744 "description" => Ok(Field::Description),
745 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
746 "identifier" => Ok(Field::Identifier),
747 "image" => Ok(Field::Image),
748 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
749 "name" => Ok(Field::Name),
750 "potentialAction" => Ok(Field::PotentialAction),
751 "sameAs" => Ok(Field::SameAs),
752 "subjectOf" => Ok(Field::SubjectOf),
753 "url" => Ok(Field::Url),
754 "id" | "type" => Ok(Field::Ignore),
755 _ => Err(de::Error::unknown_field(value, FIELDS)),
756 }
757 }
758 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
759 where
760 E: de::Error,
761 {
762 match value {
763 b"actionStatus" => Ok(Field::ActionStatus),
764 b"agent" => Ok(Field::Agent),
765 b"endTime" => Ok(Field::EndTime),
766 b"error" => Ok(Field::Error),
767 b"instrument" => Ok(Field::Instrument),
768 b"location" => Ok(Field::Location),
769 b"object" => Ok(Field::Object),
770 b"participant" => Ok(Field::Participant),
771 b"provider" => Ok(Field::Provider),
772 b"result" => Ok(Field::Result),
773 b"startTime" => Ok(Field::StartTime),
774 b"target" => Ok(Field::Target),
775 b"additionalType" => Ok(Field::AdditionalType),
776 b"alternateName" => Ok(Field::AlternateName),
777 b"description" => Ok(Field::Description),
778 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
779 b"identifier" => Ok(Field::Identifier),
780 b"image" => Ok(Field::Image),
781 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
782 b"name" => Ok(Field::Name),
783 b"potentialAction" => Ok(Field::PotentialAction),
784 b"sameAs" => Ok(Field::SameAs),
785 b"subjectOf" => Ok(Field::SubjectOf),
786 b"url" => Ok(Field::Url),
787 b"id" | b"type" => Ok(Field::Ignore),
788 _ => {
789 let value = &String::from_utf8_lossy(value);
790 Err(de::Error::unknown_field(value, FIELDS))
791 }
792 }
793 }
794 }
795 impl<'de> Deserialize<'de> for Field {
796 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
797 where
798 D: Deserializer<'de>,
799 {
800 deserializer.deserialize_identifier(FieldVisitor)
801 }
802 }
803 struct ClassVisitor;
804 impl<'de> Visitor<'de> for ClassVisitor {
805 type Value = AcceptAction;
806 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
807 formatter.write_str("schema.org schema AcceptAction")
808 }
809 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
810 where
811 A: de::MapAccess<'de>,
812 {
813 let mut r#action_status_property = None;
814 let mut r#agent_property = None;
815 let mut r#end_time_property = None;
816 let mut r#error_property = None;
817 let mut r#instrument_property = None;
818 let mut r#location_property = None;
819 let mut r#object_property = None;
820 let mut r#participant_property = None;
821 let mut r#provider_property = None;
822 let mut r#result_property = None;
823 let mut r#start_time_property = None;
824 let mut r#target_property = None;
825 let mut r#additional_type_property = None;
826 let mut r#alternate_name_property = None;
827 let mut r#description_property = None;
828 let mut r#disambiguating_description_property = None;
829 let mut r#identifier_property = None;
830 let mut r#image_property = None;
831 let mut r#main_entity_of_page_property = None;
832 let mut r#name_property = None;
833 let mut r#potential_action_property = None;
834 let mut r#same_as_property = None;
835 let mut r#subject_of_property = None;
836 let mut r#url_property = None;
837 while let Some(key) = map.next_key::<Field>()? {
838 match key {
839 Field::ActionStatus => {
840 if r#action_status_property.is_some() {
841 return Err(<A::Error as de::Error>::duplicate_field(
842 "actionStatus",
843 ));
844 }
845 r#action_status_property = Some({
846 struct DeserializeWith(Vec<ActionStatusProperty>);
847 impl<'de> Deserialize<'de> for DeserializeWith {
848 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
849 where
850 D: Deserializer<'de>,
851 {
852 Ok(DeserializeWith(serde_with::As::<
853 serde_with::OneOrMany<serde_with::Same>,
854 >::deserialize(deserializer)?))
855 }
856 }
857 match map.next_value::<DeserializeWith>() {
858 Ok(deserialize_with) => deserialize_with.0,
859 Err(err) => {
860 return Err(err);
861 }
862 }
863 });
864 }
865 Field::Agent => {
866 if r#agent_property.is_some() {
867 return Err(<A::Error as de::Error>::duplicate_field("agent"));
868 }
869 r#agent_property = Some({
870 struct DeserializeWith(Vec<AgentProperty>);
871 impl<'de> Deserialize<'de> for DeserializeWith {
872 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
873 where
874 D: Deserializer<'de>,
875 {
876 Ok(DeserializeWith(serde_with::As::<
877 serde_with::OneOrMany<serde_with::Same>,
878 >::deserialize(deserializer)?))
879 }
880 }
881 match map.next_value::<DeserializeWith>() {
882 Ok(deserialize_with) => deserialize_with.0,
883 Err(err) => {
884 return Err(err);
885 }
886 }
887 });
888 }
889 Field::EndTime => {
890 if r#end_time_property.is_some() {
891 return Err(<A::Error as de::Error>::duplicate_field(
892 "endTime",
893 ));
894 }
895 r#end_time_property = Some({
896 struct DeserializeWith(Vec<EndTimeProperty>);
897 impl<'de> Deserialize<'de> for DeserializeWith {
898 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
899 where
900 D: Deserializer<'de>,
901 {
902 Ok(DeserializeWith(serde_with::As::<
903 serde_with::OneOrMany<serde_with::Same>,
904 >::deserialize(deserializer)?))
905 }
906 }
907 match map.next_value::<DeserializeWith>() {
908 Ok(deserialize_with) => deserialize_with.0,
909 Err(err) => {
910 return Err(err);
911 }
912 }
913 });
914 }
915 Field::Error => {
916 if r#error_property.is_some() {
917 return Err(<A::Error as de::Error>::duplicate_field("error"));
918 }
919 r#error_property = Some({
920 struct DeserializeWith(Vec<ErrorProperty>);
921 impl<'de> Deserialize<'de> for DeserializeWith {
922 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
923 where
924 D: Deserializer<'de>,
925 {
926 Ok(DeserializeWith(serde_with::As::<
927 serde_with::OneOrMany<serde_with::Same>,
928 >::deserialize(deserializer)?))
929 }
930 }
931 match map.next_value::<DeserializeWith>() {
932 Ok(deserialize_with) => deserialize_with.0,
933 Err(err) => {
934 return Err(err);
935 }
936 }
937 });
938 }
939 Field::Instrument => {
940 if r#instrument_property.is_some() {
941 return Err(<A::Error as de::Error>::duplicate_field(
942 "instrument",
943 ));
944 }
945 r#instrument_property = Some({
946 struct DeserializeWith(Vec<InstrumentProperty>);
947 impl<'de> Deserialize<'de> for DeserializeWith {
948 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
949 where
950 D: Deserializer<'de>,
951 {
952 Ok(DeserializeWith(serde_with::As::<
953 serde_with::OneOrMany<serde_with::Same>,
954 >::deserialize(deserializer)?))
955 }
956 }
957 match map.next_value::<DeserializeWith>() {
958 Ok(deserialize_with) => deserialize_with.0,
959 Err(err) => {
960 return Err(err);
961 }
962 }
963 });
964 }
965 Field::Location => {
966 if r#location_property.is_some() {
967 return Err(<A::Error as de::Error>::duplicate_field(
968 "location",
969 ));
970 }
971 r#location_property = Some({
972 struct DeserializeWith(Vec<LocationProperty>);
973 impl<'de> Deserialize<'de> for DeserializeWith {
974 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
975 where
976 D: Deserializer<'de>,
977 {
978 Ok(DeserializeWith(serde_with::As::<
979 serde_with::OneOrMany<serde_with::Same>,
980 >::deserialize(deserializer)?))
981 }
982 }
983 match map.next_value::<DeserializeWith>() {
984 Ok(deserialize_with) => deserialize_with.0,
985 Err(err) => {
986 return Err(err);
987 }
988 }
989 });
990 }
991 Field::Object => {
992 if r#object_property.is_some() {
993 return Err(<A::Error as de::Error>::duplicate_field("object"));
994 }
995 r#object_property = Some({
996 struct DeserializeWith(Vec<ObjectProperty>);
997 impl<'de> Deserialize<'de> for DeserializeWith {
998 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
999 where
1000 D: Deserializer<'de>,
1001 {
1002 Ok(DeserializeWith(serde_with::As::<
1003 serde_with::OneOrMany<serde_with::Same>,
1004 >::deserialize(deserializer)?))
1005 }
1006 }
1007 match map.next_value::<DeserializeWith>() {
1008 Ok(deserialize_with) => deserialize_with.0,
1009 Err(err) => {
1010 return Err(err);
1011 }
1012 }
1013 });
1014 }
1015 Field::Participant => {
1016 if r#participant_property.is_some() {
1017 return Err(<A::Error as de::Error>::duplicate_field(
1018 "participant",
1019 ));
1020 }
1021 r#participant_property = Some({
1022 struct DeserializeWith(Vec<ParticipantProperty>);
1023 impl<'de> Deserialize<'de> for DeserializeWith {
1024 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1025 where
1026 D: Deserializer<'de>,
1027 {
1028 Ok(DeserializeWith(serde_with::As::<
1029 serde_with::OneOrMany<serde_with::Same>,
1030 >::deserialize(deserializer)?))
1031 }
1032 }
1033 match map.next_value::<DeserializeWith>() {
1034 Ok(deserialize_with) => deserialize_with.0,
1035 Err(err) => {
1036 return Err(err);
1037 }
1038 }
1039 });
1040 }
1041 Field::Provider => {
1042 if r#provider_property.is_some() {
1043 return Err(<A::Error as de::Error>::duplicate_field(
1044 "provider",
1045 ));
1046 }
1047 r#provider_property = Some({
1048 struct DeserializeWith(Vec<ProviderProperty>);
1049 impl<'de> Deserialize<'de> for DeserializeWith {
1050 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1051 where
1052 D: Deserializer<'de>,
1053 {
1054 Ok(DeserializeWith(serde_with::As::<
1055 serde_with::OneOrMany<serde_with::Same>,
1056 >::deserialize(deserializer)?))
1057 }
1058 }
1059 match map.next_value::<DeserializeWith>() {
1060 Ok(deserialize_with) => deserialize_with.0,
1061 Err(err) => {
1062 return Err(err);
1063 }
1064 }
1065 });
1066 }
1067 Field::Result => {
1068 if r#result_property.is_some() {
1069 return Err(<A::Error as de::Error>::duplicate_field("result"));
1070 }
1071 r#result_property = Some({
1072 struct DeserializeWith(Vec<ResultProperty>);
1073 impl<'de> Deserialize<'de> for DeserializeWith {
1074 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1075 where
1076 D: Deserializer<'de>,
1077 {
1078 Ok(DeserializeWith(serde_with::As::<
1079 serde_with::OneOrMany<serde_with::Same>,
1080 >::deserialize(deserializer)?))
1081 }
1082 }
1083 match map.next_value::<DeserializeWith>() {
1084 Ok(deserialize_with) => deserialize_with.0,
1085 Err(err) => {
1086 return Err(err);
1087 }
1088 }
1089 });
1090 }
1091 Field::StartTime => {
1092 if r#start_time_property.is_some() {
1093 return Err(<A::Error as de::Error>::duplicate_field(
1094 "startTime",
1095 ));
1096 }
1097 r#start_time_property = Some({
1098 struct DeserializeWith(Vec<StartTimeProperty>);
1099 impl<'de> Deserialize<'de> for DeserializeWith {
1100 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1101 where
1102 D: Deserializer<'de>,
1103 {
1104 Ok(DeserializeWith(serde_with::As::<
1105 serde_with::OneOrMany<serde_with::Same>,
1106 >::deserialize(deserializer)?))
1107 }
1108 }
1109 match map.next_value::<DeserializeWith>() {
1110 Ok(deserialize_with) => deserialize_with.0,
1111 Err(err) => {
1112 return Err(err);
1113 }
1114 }
1115 });
1116 }
1117 Field::Target => {
1118 if r#target_property.is_some() {
1119 return Err(<A::Error as de::Error>::duplicate_field("target"));
1120 }
1121 r#target_property = Some({
1122 struct DeserializeWith(Vec<TargetProperty>);
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::AdditionalType => {
1142 if r#additional_type_property.is_some() {
1143 return Err(<A::Error as de::Error>::duplicate_field(
1144 "additionalType",
1145 ));
1146 }
1147 r#additional_type_property = Some({
1148 struct DeserializeWith(Vec<AdditionalTypeProperty>);
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::AlternateName => {
1168 if r#alternate_name_property.is_some() {
1169 return Err(<A::Error as de::Error>::duplicate_field(
1170 "alternateName",
1171 ));
1172 }
1173 r#alternate_name_property = Some({
1174 struct DeserializeWith(Vec<AlternateNameProperty>);
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::Description => {
1194 if r#description_property.is_some() {
1195 return Err(<A::Error as de::Error>::duplicate_field(
1196 "description",
1197 ));
1198 }
1199 r#description_property = Some({
1200 struct DeserializeWith(Vec<DescriptionProperty>);
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::DisambiguatingDescription => {
1220 if r#disambiguating_description_property.is_some() {
1221 return Err(<A::Error as de::Error>::duplicate_field(
1222 "disambiguatingDescription",
1223 ));
1224 }
1225 r#disambiguating_description_property = Some({
1226 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
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::Identifier => {
1246 if r#identifier_property.is_some() {
1247 return Err(<A::Error as de::Error>::duplicate_field(
1248 "identifier",
1249 ));
1250 }
1251 r#identifier_property = Some({
1252 struct DeserializeWith(Vec<IdentifierProperty>);
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::Image => {
1272 if r#image_property.is_some() {
1273 return Err(<A::Error as de::Error>::duplicate_field("image"));
1274 }
1275 r#image_property = Some({
1276 struct DeserializeWith(Vec<ImageProperty>);
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::MainEntityOfPage => {
1296 if r#main_entity_of_page_property.is_some() {
1297 return Err(<A::Error as de::Error>::duplicate_field(
1298 "mainEntityOfPage",
1299 ));
1300 }
1301 r#main_entity_of_page_property = Some({
1302 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
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::Name => {
1322 if r#name_property.is_some() {
1323 return Err(<A::Error as de::Error>::duplicate_field("name"));
1324 }
1325 r#name_property = Some({
1326 struct DeserializeWith(Vec<NameProperty>);
1327 impl<'de> Deserialize<'de> for DeserializeWith {
1328 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1329 where
1330 D: Deserializer<'de>,
1331 {
1332 Ok(DeserializeWith(serde_with::As::<
1333 serde_with::OneOrMany<serde_with::Same>,
1334 >::deserialize(deserializer)?))
1335 }
1336 }
1337 match map.next_value::<DeserializeWith>() {
1338 Ok(deserialize_with) => deserialize_with.0,
1339 Err(err) => {
1340 return Err(err);
1341 }
1342 }
1343 });
1344 }
1345 Field::PotentialAction => {
1346 if r#potential_action_property.is_some() {
1347 return Err(<A::Error as de::Error>::duplicate_field(
1348 "potentialAction",
1349 ));
1350 }
1351 r#potential_action_property = Some({
1352 struct DeserializeWith(Vec<PotentialActionProperty>);
1353 impl<'de> Deserialize<'de> for DeserializeWith {
1354 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1355 where
1356 D: Deserializer<'de>,
1357 {
1358 Ok(DeserializeWith(serde_with::As::<
1359 serde_with::OneOrMany<serde_with::Same>,
1360 >::deserialize(deserializer)?))
1361 }
1362 }
1363 match map.next_value::<DeserializeWith>() {
1364 Ok(deserialize_with) => deserialize_with.0,
1365 Err(err) => {
1366 return Err(err);
1367 }
1368 }
1369 });
1370 }
1371 Field::SameAs => {
1372 if r#same_as_property.is_some() {
1373 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1374 }
1375 r#same_as_property = Some({
1376 struct DeserializeWith(Vec<SameAsProperty>);
1377 impl<'de> Deserialize<'de> for DeserializeWith {
1378 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1379 where
1380 D: Deserializer<'de>,
1381 {
1382 Ok(DeserializeWith(serde_with::As::<
1383 serde_with::OneOrMany<serde_with::Same>,
1384 >::deserialize(deserializer)?))
1385 }
1386 }
1387 match map.next_value::<DeserializeWith>() {
1388 Ok(deserialize_with) => deserialize_with.0,
1389 Err(err) => {
1390 return Err(err);
1391 }
1392 }
1393 });
1394 }
1395 Field::SubjectOf => {
1396 if r#subject_of_property.is_some() {
1397 return Err(<A::Error as de::Error>::duplicate_field(
1398 "subjectOf",
1399 ));
1400 }
1401 r#subject_of_property = Some({
1402 struct DeserializeWith(Vec<SubjectOfProperty>);
1403 impl<'de> Deserialize<'de> for DeserializeWith {
1404 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1405 where
1406 D: Deserializer<'de>,
1407 {
1408 Ok(DeserializeWith(serde_with::As::<
1409 serde_with::OneOrMany<serde_with::Same>,
1410 >::deserialize(deserializer)?))
1411 }
1412 }
1413 match map.next_value::<DeserializeWith>() {
1414 Ok(deserialize_with) => deserialize_with.0,
1415 Err(err) => {
1416 return Err(err);
1417 }
1418 }
1419 });
1420 }
1421 Field::Url => {
1422 if r#url_property.is_some() {
1423 return Err(<A::Error as de::Error>::duplicate_field("url"));
1424 }
1425 r#url_property = Some({
1426 struct DeserializeWith(Vec<UrlProperty>);
1427 impl<'de> Deserialize<'de> for DeserializeWith {
1428 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1429 where
1430 D: Deserializer<'de>,
1431 {
1432 Ok(DeserializeWith(serde_with::As::<
1433 serde_with::OneOrMany<serde_with::Same>,
1434 >::deserialize(deserializer)?))
1435 }
1436 }
1437 match map.next_value::<DeserializeWith>() {
1438 Ok(deserialize_with) => deserialize_with.0,
1439 Err(err) => {
1440 return Err(err);
1441 }
1442 }
1443 });
1444 }
1445 Field::Ignore => {
1446 let _ = map.next_value::<de::IgnoredAny>()?;
1447 }
1448 }
1449 }
1450 Ok(AcceptAction {
1451 r#action_status: r#action_status_property.unwrap_or_default(),
1452 r#agent: r#agent_property.unwrap_or_default(),
1453 r#end_time: r#end_time_property.unwrap_or_default(),
1454 r#error: r#error_property.unwrap_or_default(),
1455 r#instrument: r#instrument_property.unwrap_or_default(),
1456 r#location: r#location_property.unwrap_or_default(),
1457 r#object: r#object_property.unwrap_or_default(),
1458 r#participant: r#participant_property.unwrap_or_default(),
1459 r#provider: r#provider_property.unwrap_or_default(),
1460 r#result: r#result_property.unwrap_or_default(),
1461 r#start_time: r#start_time_property.unwrap_or_default(),
1462 r#target: r#target_property.unwrap_or_default(),
1463 r#additional_type: r#additional_type_property.unwrap_or_default(),
1464 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1465 r#description: r#description_property.unwrap_or_default(),
1466 r#disambiguating_description: r#disambiguating_description_property
1467 .unwrap_or_default(),
1468 r#identifier: r#identifier_property.unwrap_or_default(),
1469 r#image: r#image_property.unwrap_or_default(),
1470 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1471 r#name: r#name_property.unwrap_or_default(),
1472 r#potential_action: r#potential_action_property.unwrap_or_default(),
1473 r#same_as: r#same_as_property.unwrap_or_default(),
1474 r#subject_of: r#subject_of_property.unwrap_or_default(),
1475 r#url: r#url_property.unwrap_or_default(),
1476 })
1477 }
1478 }
1479 const FIELDS: &[&str] = &[
1480 "actionStatus",
1481 "agent",
1482 "endTime",
1483 "error",
1484 "instrument",
1485 "location",
1486 "object",
1487 "participant",
1488 "provider",
1489 "result",
1490 "startTime",
1491 "target",
1492 "additionalType",
1493 "alternateName",
1494 "description",
1495 "disambiguatingDescription",
1496 "identifier",
1497 "image",
1498 "mainEntityOfPage",
1499 "name",
1500 "potentialAction",
1501 "sameAs",
1502 "subjectOf",
1503 "url",
1504 ];
1505 deserializer.deserialize_struct("AcceptAction", FIELDS, ClassVisitor)
1506 }
1507 }
1508}