1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct TvSeason {
6 pub r#country_of_origin: Vec<CountryOfOriginProperty>,
8 #[deprecated = "This schema is superseded by <https://schema.org/partOfSeries>."]
10 pub r#part_of_tv_series: Vec<PartOfTvSeriesProperty>,
11 pub r#title_eidr: Vec<TitleEidrProperty>,
13 pub r#about: Vec<AboutProperty>,
15 pub r#abstract: Vec<AbstractProperty>,
17 pub r#access_mode: Vec<AccessModeProperty>,
19 pub r#access_mode_sufficient: Vec<AccessModeSufficientProperty>,
21 pub r#accessibility_api: Vec<AccessibilityApiProperty>,
23 pub r#accessibility_control: Vec<AccessibilityControlProperty>,
25 pub r#accessibility_feature: Vec<AccessibilityFeatureProperty>,
27 pub r#accessibility_hazard: Vec<AccessibilityHazardProperty>,
29 pub r#accessibility_summary: Vec<AccessibilitySummaryProperty>,
31 pub r#accountable_person: Vec<AccountablePersonProperty>,
33 pub r#acquire_license_page: Vec<AcquireLicensePageProperty>,
35 pub r#aggregate_rating: Vec<AggregateRatingProperty>,
37 pub r#alternative_headline: Vec<AlternativeHeadlineProperty>,
39 pub r#archived_at: Vec<ArchivedAtProperty>,
41 pub r#assesses: Vec<AssessesProperty>,
43 pub r#associated_media: Vec<AssociatedMediaProperty>,
45 pub r#audience: Vec<AudienceProperty>,
47 pub r#audio: Vec<AudioProperty>,
49 pub r#author: Vec<AuthorProperty>,
51 pub r#award: Vec<AwardProperty>,
53 #[deprecated = "This schema is superseded by <https://schema.org/award>."]
55 pub r#awards: Vec<AwardsProperty>,
56 pub r#character: Vec<CharacterProperty>,
58 pub r#citation: Vec<CitationProperty>,
60 pub r#comment: Vec<CommentProperty>,
62 pub r#comment_count: Vec<CommentCountProperty>,
64 pub r#conditions_of_access: Vec<ConditionsOfAccessProperty>,
66 pub r#content_location: Vec<ContentLocationProperty>,
68 pub r#content_rating: Vec<ContentRatingProperty>,
70 pub r#content_reference_time: Vec<ContentReferenceTimeProperty>,
72 pub r#contributor: Vec<ContributorProperty>,
74 pub r#copyright_holder: Vec<CopyrightHolderProperty>,
76 pub r#copyright_notice: Vec<CopyrightNoticeProperty>,
78 pub r#copyright_year: Vec<CopyrightYearProperty>,
80 pub r#correction: Vec<CorrectionProperty>,
82 pub r#creative_work_status: Vec<CreativeWorkStatusProperty>,
84 pub r#creator: Vec<CreatorProperty>,
86 pub r#credit_text: Vec<CreditTextProperty>,
88 pub r#date_created: Vec<DateCreatedProperty>,
90 pub r#date_modified: Vec<DateModifiedProperty>,
92 pub r#date_published: Vec<DatePublishedProperty>,
94 pub r#discussion_url: Vec<DiscussionUrlProperty>,
96 pub r#edit_eidr: Vec<EditEidrProperty>,
98 pub r#editor: Vec<EditorProperty>,
100 pub r#educational_alignment: Vec<EducationalAlignmentProperty>,
102 pub r#educational_level: Vec<EducationalLevelProperty>,
104 pub r#educational_use: Vec<EducationalUseProperty>,
106 pub r#encoding: Vec<EncodingProperty>,
108 pub r#encoding_format: Vec<EncodingFormatProperty>,
110 #[deprecated = "This schema is superseded by <https://schema.org/encoding>."]
112 pub r#encodings: Vec<EncodingsProperty>,
113 pub r#example_of_work: Vec<ExampleOfWorkProperty>,
115 pub r#expires: Vec<ExpiresProperty>,
117 #[deprecated = "This schema is superseded by <https://schema.org/encodingFormat>."]
119 pub r#file_format: Vec<FileFormatProperty>,
120 pub r#funder: Vec<FunderProperty>,
122 pub r#funding: Vec<FundingProperty>,
124 pub r#genre: Vec<GenreProperty>,
126 pub r#has_part: Vec<HasPartProperty>,
128 pub r#headline: Vec<HeadlineProperty>,
130 pub r#in_language: Vec<InLanguageProperty>,
132 pub r#interaction_statistic: Vec<InteractionStatisticProperty>,
134 pub r#interactivity_type: Vec<InteractivityTypeProperty>,
136 pub r#interpreted_as_claim: Vec<InterpretedAsClaimProperty>,
138 pub r#is_accessible_for_free: Vec<IsAccessibleForFreeProperty>,
140 pub r#is_based_on: Vec<IsBasedOnProperty>,
142 #[deprecated = "This schema is superseded by <https://schema.org/isBasedOn>."]
144 pub r#is_based_on_url: Vec<IsBasedOnUrlProperty>,
145 pub r#is_family_friendly: Vec<IsFamilyFriendlyProperty>,
147 pub r#is_part_of: Vec<IsPartOfProperty>,
149 pub r#keywords: Vec<KeywordsProperty>,
151 pub r#learning_resource_type: Vec<LearningResourceTypeProperty>,
153 pub r#license: Vec<LicenseProperty>,
155 pub r#location_created: Vec<LocationCreatedProperty>,
157 pub r#main_entity: Vec<MainEntityProperty>,
159 pub r#maintainer: Vec<MaintainerProperty>,
161 pub r#material: Vec<MaterialProperty>,
163 pub r#material_extent: Vec<MaterialExtentProperty>,
165 pub r#mentions: Vec<MentionsProperty>,
167 pub r#offers: Vec<OffersProperty>,
169 pub r#pattern: Vec<PatternProperty>,
171 pub r#position: Vec<PositionProperty>,
173 pub r#producer: Vec<ProducerProperty>,
175 pub r#provider: Vec<ProviderProperty>,
177 pub r#publication: Vec<PublicationProperty>,
179 pub r#publisher: Vec<PublisherProperty>,
181 pub r#publisher_imprint: Vec<PublisherImprintProperty>,
183 pub r#publishing_principles: Vec<PublishingPrinciplesProperty>,
185 pub r#recorded_at: Vec<RecordedAtProperty>,
187 pub r#released_event: Vec<ReleasedEventProperty>,
189 pub r#review: Vec<ReviewProperty>,
191 #[deprecated = "This schema is superseded by <https://schema.org/review>."]
193 pub r#reviews: Vec<ReviewsProperty>,
194 pub r#schema_version: Vec<SchemaVersionProperty>,
196 pub r#sd_date_published: Vec<SdDatePublishedProperty>,
198 pub r#sd_license: Vec<SdLicenseProperty>,
200 pub r#sd_publisher: Vec<SdPublisherProperty>,
202 pub r#size: Vec<SizeProperty>,
204 pub r#source_organization: Vec<SourceOrganizationProperty>,
206 pub r#spatial: Vec<SpatialProperty>,
208 pub r#spatial_coverage: Vec<SpatialCoverageProperty>,
210 pub r#sponsor: Vec<SponsorProperty>,
212 pub r#teaches: Vec<TeachesProperty>,
214 pub r#temporal: Vec<TemporalProperty>,
216 pub r#temporal_coverage: Vec<TemporalCoverageProperty>,
218 pub r#text: Vec<TextProperty>,
220 pub r#thumbnail: Vec<ThumbnailProperty>,
222 pub r#thumbnail_url: Vec<ThumbnailUrlProperty>,
224 pub r#time_required: Vec<TimeRequiredProperty>,
226 pub r#translation_of_work: Vec<TranslationOfWorkProperty>,
228 pub r#translator: Vec<TranslatorProperty>,
230 pub r#typical_age_range: Vec<TypicalAgeRangeProperty>,
232 pub r#usage_info: Vec<UsageInfoProperty>,
234 pub r#version: Vec<VersionProperty>,
236 pub r#video: Vec<VideoProperty>,
238 pub r#work_example: Vec<WorkExampleProperty>,
240 pub r#work_translation: Vec<WorkTranslationProperty>,
242 pub r#actor: Vec<ActorProperty>,
244 pub r#director: Vec<DirectorProperty>,
246 pub r#end_date: Vec<EndDateProperty>,
248 pub r#episode: Vec<EpisodeProperty>,
250 #[deprecated = "This schema is superseded by <https://schema.org/episode>."]
252 pub r#episodes: Vec<EpisodesProperty>,
253 pub r#number_of_episodes: Vec<NumberOfEpisodesProperty>,
255 pub r#part_of_series: Vec<PartOfSeriesProperty>,
257 pub r#production_company: Vec<ProductionCompanyProperty>,
259 pub r#season_number: Vec<SeasonNumberProperty>,
261 pub r#start_date: Vec<StartDateProperty>,
263 pub r#trailer: Vec<TrailerProperty>,
265 pub r#additional_type: Vec<AdditionalTypeProperty>,
267 pub r#alternate_name: Vec<AlternateNameProperty>,
269 pub r#description: Vec<DescriptionProperty>,
271 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
273 pub r#identifier: Vec<IdentifierProperty>,
275 pub r#image: Vec<ImageProperty>,
277 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
279 pub r#name: Vec<NameProperty>,
281 pub r#potential_action: Vec<PotentialActionProperty>,
283 pub r#same_as: Vec<SameAsProperty>,
285 pub r#subject_of: Vec<SubjectOfProperty>,
287 pub r#url: Vec<UrlProperty>,
289}
290pub trait TvSeasonTrait {
292 fn get_country_of_origin(&self) -> &[CountryOfOriginProperty];
294 fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty>;
296 #[deprecated = "This schema is superseded by <https://schema.org/partOfSeries>."]
298 fn get_part_of_tv_series(&self) -> &[PartOfTvSeriesProperty];
299 #[deprecated = "This schema is superseded by <https://schema.org/partOfSeries>."]
301 fn take_part_of_tv_series(&mut self) -> Vec<PartOfTvSeriesProperty>;
302 fn get_title_eidr(&self) -> &[TitleEidrProperty];
304 fn take_title_eidr(&mut self) -> Vec<TitleEidrProperty>;
306}
307impl TvSeasonTrait for TvSeason {
308 fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
309 self.r#country_of_origin.as_slice()
310 }
311 fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
312 std::mem::take(&mut self.r#country_of_origin)
313 }
314 fn get_part_of_tv_series(&self) -> &[PartOfTvSeriesProperty] {
315 self.r#part_of_tv_series.as_slice()
316 }
317 fn take_part_of_tv_series(&mut self) -> Vec<PartOfTvSeriesProperty> {
318 std::mem::take(&mut self.r#part_of_tv_series)
319 }
320 fn get_title_eidr(&self) -> &[TitleEidrProperty] {
321 self.r#title_eidr.as_slice()
322 }
323 fn take_title_eidr(&mut self) -> Vec<TitleEidrProperty> {
324 std::mem::take(&mut self.r#title_eidr)
325 }
326}
327impl CreativeWorkTrait for TvSeason {
328 fn get_about(&self) -> &[AboutProperty] {
329 self.r#about.as_slice()
330 }
331 fn take_about(&mut self) -> Vec<AboutProperty> {
332 std::mem::take(&mut self.r#about)
333 }
334 fn get_abstract(&self) -> &[AbstractProperty] {
335 self.r#abstract.as_slice()
336 }
337 fn take_abstract(&mut self) -> Vec<AbstractProperty> {
338 std::mem::take(&mut self.r#abstract)
339 }
340 fn get_access_mode(&self) -> &[AccessModeProperty] {
341 self.r#access_mode.as_slice()
342 }
343 fn take_access_mode(&mut self) -> Vec<AccessModeProperty> {
344 std::mem::take(&mut self.r#access_mode)
345 }
346 fn get_access_mode_sufficient(&self) -> &[AccessModeSufficientProperty] {
347 self.r#access_mode_sufficient.as_slice()
348 }
349 fn take_access_mode_sufficient(&mut self) -> Vec<AccessModeSufficientProperty> {
350 std::mem::take(&mut self.r#access_mode_sufficient)
351 }
352 fn get_accessibility_api(&self) -> &[AccessibilityApiProperty] {
353 self.r#accessibility_api.as_slice()
354 }
355 fn take_accessibility_api(&mut self) -> Vec<AccessibilityApiProperty> {
356 std::mem::take(&mut self.r#accessibility_api)
357 }
358 fn get_accessibility_control(&self) -> &[AccessibilityControlProperty] {
359 self.r#accessibility_control.as_slice()
360 }
361 fn take_accessibility_control(&mut self) -> Vec<AccessibilityControlProperty> {
362 std::mem::take(&mut self.r#accessibility_control)
363 }
364 fn get_accessibility_feature(&self) -> &[AccessibilityFeatureProperty] {
365 self.r#accessibility_feature.as_slice()
366 }
367 fn take_accessibility_feature(&mut self) -> Vec<AccessibilityFeatureProperty> {
368 std::mem::take(&mut self.r#accessibility_feature)
369 }
370 fn get_accessibility_hazard(&self) -> &[AccessibilityHazardProperty] {
371 self.r#accessibility_hazard.as_slice()
372 }
373 fn take_accessibility_hazard(&mut self) -> Vec<AccessibilityHazardProperty> {
374 std::mem::take(&mut self.r#accessibility_hazard)
375 }
376 fn get_accessibility_summary(&self) -> &[AccessibilitySummaryProperty] {
377 self.r#accessibility_summary.as_slice()
378 }
379 fn take_accessibility_summary(&mut self) -> Vec<AccessibilitySummaryProperty> {
380 std::mem::take(&mut self.r#accessibility_summary)
381 }
382 fn get_accountable_person(&self) -> &[AccountablePersonProperty] {
383 self.r#accountable_person.as_slice()
384 }
385 fn take_accountable_person(&mut self) -> Vec<AccountablePersonProperty> {
386 std::mem::take(&mut self.r#accountable_person)
387 }
388 fn get_acquire_license_page(&self) -> &[AcquireLicensePageProperty] {
389 self.r#acquire_license_page.as_slice()
390 }
391 fn take_acquire_license_page(&mut self) -> Vec<AcquireLicensePageProperty> {
392 std::mem::take(&mut self.r#acquire_license_page)
393 }
394 fn get_aggregate_rating(&self) -> &[AggregateRatingProperty] {
395 self.r#aggregate_rating.as_slice()
396 }
397 fn take_aggregate_rating(&mut self) -> Vec<AggregateRatingProperty> {
398 std::mem::take(&mut self.r#aggregate_rating)
399 }
400 fn get_alternative_headline(&self) -> &[AlternativeHeadlineProperty] {
401 self.r#alternative_headline.as_slice()
402 }
403 fn take_alternative_headline(&mut self) -> Vec<AlternativeHeadlineProperty> {
404 std::mem::take(&mut self.r#alternative_headline)
405 }
406 fn get_archived_at(&self) -> &[ArchivedAtProperty] {
407 self.r#archived_at.as_slice()
408 }
409 fn take_archived_at(&mut self) -> Vec<ArchivedAtProperty> {
410 std::mem::take(&mut self.r#archived_at)
411 }
412 fn get_assesses(&self) -> &[AssessesProperty] {
413 self.r#assesses.as_slice()
414 }
415 fn take_assesses(&mut self) -> Vec<AssessesProperty> {
416 std::mem::take(&mut self.r#assesses)
417 }
418 fn get_associated_media(&self) -> &[AssociatedMediaProperty] {
419 self.r#associated_media.as_slice()
420 }
421 fn take_associated_media(&mut self) -> Vec<AssociatedMediaProperty> {
422 std::mem::take(&mut self.r#associated_media)
423 }
424 fn get_audience(&self) -> &[AudienceProperty] {
425 self.r#audience.as_slice()
426 }
427 fn take_audience(&mut self) -> Vec<AudienceProperty> {
428 std::mem::take(&mut self.r#audience)
429 }
430 fn get_audio(&self) -> &[AudioProperty] {
431 self.r#audio.as_slice()
432 }
433 fn take_audio(&mut self) -> Vec<AudioProperty> {
434 std::mem::take(&mut self.r#audio)
435 }
436 fn get_author(&self) -> &[AuthorProperty] {
437 self.r#author.as_slice()
438 }
439 fn take_author(&mut self) -> Vec<AuthorProperty> {
440 std::mem::take(&mut self.r#author)
441 }
442 fn get_award(&self) -> &[AwardProperty] {
443 self.r#award.as_slice()
444 }
445 fn take_award(&mut self) -> Vec<AwardProperty> {
446 std::mem::take(&mut self.r#award)
447 }
448 fn get_awards(&self) -> &[AwardsProperty] {
449 self.r#awards.as_slice()
450 }
451 fn take_awards(&mut self) -> Vec<AwardsProperty> {
452 std::mem::take(&mut self.r#awards)
453 }
454 fn get_character(&self) -> &[CharacterProperty] {
455 self.r#character.as_slice()
456 }
457 fn take_character(&mut self) -> Vec<CharacterProperty> {
458 std::mem::take(&mut self.r#character)
459 }
460 fn get_citation(&self) -> &[CitationProperty] {
461 self.r#citation.as_slice()
462 }
463 fn take_citation(&mut self) -> Vec<CitationProperty> {
464 std::mem::take(&mut self.r#citation)
465 }
466 fn get_comment(&self) -> &[CommentProperty] {
467 self.r#comment.as_slice()
468 }
469 fn take_comment(&mut self) -> Vec<CommentProperty> {
470 std::mem::take(&mut self.r#comment)
471 }
472 fn get_comment_count(&self) -> &[CommentCountProperty] {
473 self.r#comment_count.as_slice()
474 }
475 fn take_comment_count(&mut self) -> Vec<CommentCountProperty> {
476 std::mem::take(&mut self.r#comment_count)
477 }
478 fn get_conditions_of_access(&self) -> &[ConditionsOfAccessProperty] {
479 self.r#conditions_of_access.as_slice()
480 }
481 fn take_conditions_of_access(&mut self) -> Vec<ConditionsOfAccessProperty> {
482 std::mem::take(&mut self.r#conditions_of_access)
483 }
484 fn get_content_location(&self) -> &[ContentLocationProperty] {
485 self.r#content_location.as_slice()
486 }
487 fn take_content_location(&mut self) -> Vec<ContentLocationProperty> {
488 std::mem::take(&mut self.r#content_location)
489 }
490 fn get_content_rating(&self) -> &[ContentRatingProperty] {
491 self.r#content_rating.as_slice()
492 }
493 fn take_content_rating(&mut self) -> Vec<ContentRatingProperty> {
494 std::mem::take(&mut self.r#content_rating)
495 }
496 fn get_content_reference_time(&self) -> &[ContentReferenceTimeProperty] {
497 self.r#content_reference_time.as_slice()
498 }
499 fn take_content_reference_time(&mut self) -> Vec<ContentReferenceTimeProperty> {
500 std::mem::take(&mut self.r#content_reference_time)
501 }
502 fn get_contributor(&self) -> &[ContributorProperty] {
503 self.r#contributor.as_slice()
504 }
505 fn take_contributor(&mut self) -> Vec<ContributorProperty> {
506 std::mem::take(&mut self.r#contributor)
507 }
508 fn get_copyright_holder(&self) -> &[CopyrightHolderProperty] {
509 self.r#copyright_holder.as_slice()
510 }
511 fn take_copyright_holder(&mut self) -> Vec<CopyrightHolderProperty> {
512 std::mem::take(&mut self.r#copyright_holder)
513 }
514 fn get_copyright_notice(&self) -> &[CopyrightNoticeProperty] {
515 self.r#copyright_notice.as_slice()
516 }
517 fn take_copyright_notice(&mut self) -> Vec<CopyrightNoticeProperty> {
518 std::mem::take(&mut self.r#copyright_notice)
519 }
520 fn get_copyright_year(&self) -> &[CopyrightYearProperty] {
521 self.r#copyright_year.as_slice()
522 }
523 fn take_copyright_year(&mut self) -> Vec<CopyrightYearProperty> {
524 std::mem::take(&mut self.r#copyright_year)
525 }
526 fn get_correction(&self) -> &[CorrectionProperty] {
527 self.r#correction.as_slice()
528 }
529 fn take_correction(&mut self) -> Vec<CorrectionProperty> {
530 std::mem::take(&mut self.r#correction)
531 }
532 fn get_country_of_origin(&self) -> &[CountryOfOriginProperty] {
533 self.r#country_of_origin.as_slice()
534 }
535 fn take_country_of_origin(&mut self) -> Vec<CountryOfOriginProperty> {
536 std::mem::take(&mut self.r#country_of_origin)
537 }
538 fn get_creative_work_status(&self) -> &[CreativeWorkStatusProperty] {
539 self.r#creative_work_status.as_slice()
540 }
541 fn take_creative_work_status(&mut self) -> Vec<CreativeWorkStatusProperty> {
542 std::mem::take(&mut self.r#creative_work_status)
543 }
544 fn get_creator(&self) -> &[CreatorProperty] {
545 self.r#creator.as_slice()
546 }
547 fn take_creator(&mut self) -> Vec<CreatorProperty> {
548 std::mem::take(&mut self.r#creator)
549 }
550 fn get_credit_text(&self) -> &[CreditTextProperty] {
551 self.r#credit_text.as_slice()
552 }
553 fn take_credit_text(&mut self) -> Vec<CreditTextProperty> {
554 std::mem::take(&mut self.r#credit_text)
555 }
556 fn get_date_created(&self) -> &[DateCreatedProperty] {
557 self.r#date_created.as_slice()
558 }
559 fn take_date_created(&mut self) -> Vec<DateCreatedProperty> {
560 std::mem::take(&mut self.r#date_created)
561 }
562 fn get_date_modified(&self) -> &[DateModifiedProperty] {
563 self.r#date_modified.as_slice()
564 }
565 fn take_date_modified(&mut self) -> Vec<DateModifiedProperty> {
566 std::mem::take(&mut self.r#date_modified)
567 }
568 fn get_date_published(&self) -> &[DatePublishedProperty] {
569 self.r#date_published.as_slice()
570 }
571 fn take_date_published(&mut self) -> Vec<DatePublishedProperty> {
572 std::mem::take(&mut self.r#date_published)
573 }
574 fn get_discussion_url(&self) -> &[DiscussionUrlProperty] {
575 self.r#discussion_url.as_slice()
576 }
577 fn take_discussion_url(&mut self) -> Vec<DiscussionUrlProperty> {
578 std::mem::take(&mut self.r#discussion_url)
579 }
580 fn get_edit_eidr(&self) -> &[EditEidrProperty] {
581 self.r#edit_eidr.as_slice()
582 }
583 fn take_edit_eidr(&mut self) -> Vec<EditEidrProperty> {
584 std::mem::take(&mut self.r#edit_eidr)
585 }
586 fn get_editor(&self) -> &[EditorProperty] {
587 self.r#editor.as_slice()
588 }
589 fn take_editor(&mut self) -> Vec<EditorProperty> {
590 std::mem::take(&mut self.r#editor)
591 }
592 fn get_educational_alignment(&self) -> &[EducationalAlignmentProperty] {
593 self.r#educational_alignment.as_slice()
594 }
595 fn take_educational_alignment(&mut self) -> Vec<EducationalAlignmentProperty> {
596 std::mem::take(&mut self.r#educational_alignment)
597 }
598 fn get_educational_level(&self) -> &[EducationalLevelProperty] {
599 self.r#educational_level.as_slice()
600 }
601 fn take_educational_level(&mut self) -> Vec<EducationalLevelProperty> {
602 std::mem::take(&mut self.r#educational_level)
603 }
604 fn get_educational_use(&self) -> &[EducationalUseProperty] {
605 self.r#educational_use.as_slice()
606 }
607 fn take_educational_use(&mut self) -> Vec<EducationalUseProperty> {
608 std::mem::take(&mut self.r#educational_use)
609 }
610 fn get_encoding(&self) -> &[EncodingProperty] {
611 self.r#encoding.as_slice()
612 }
613 fn take_encoding(&mut self) -> Vec<EncodingProperty> {
614 std::mem::take(&mut self.r#encoding)
615 }
616 fn get_encoding_format(&self) -> &[EncodingFormatProperty] {
617 self.r#encoding_format.as_slice()
618 }
619 fn take_encoding_format(&mut self) -> Vec<EncodingFormatProperty> {
620 std::mem::take(&mut self.r#encoding_format)
621 }
622 fn get_encodings(&self) -> &[EncodingsProperty] {
623 self.r#encodings.as_slice()
624 }
625 fn take_encodings(&mut self) -> Vec<EncodingsProperty> {
626 std::mem::take(&mut self.r#encodings)
627 }
628 fn get_example_of_work(&self) -> &[ExampleOfWorkProperty] {
629 self.r#example_of_work.as_slice()
630 }
631 fn take_example_of_work(&mut self) -> Vec<ExampleOfWorkProperty> {
632 std::mem::take(&mut self.r#example_of_work)
633 }
634 fn get_expires(&self) -> &[ExpiresProperty] {
635 self.r#expires.as_slice()
636 }
637 fn take_expires(&mut self) -> Vec<ExpiresProperty> {
638 std::mem::take(&mut self.r#expires)
639 }
640 fn get_file_format(&self) -> &[FileFormatProperty] {
641 self.r#file_format.as_slice()
642 }
643 fn take_file_format(&mut self) -> Vec<FileFormatProperty> {
644 std::mem::take(&mut self.r#file_format)
645 }
646 fn get_funder(&self) -> &[FunderProperty] {
647 self.r#funder.as_slice()
648 }
649 fn take_funder(&mut self) -> Vec<FunderProperty> {
650 std::mem::take(&mut self.r#funder)
651 }
652 fn get_funding(&self) -> &[FundingProperty] {
653 self.r#funding.as_slice()
654 }
655 fn take_funding(&mut self) -> Vec<FundingProperty> {
656 std::mem::take(&mut self.r#funding)
657 }
658 fn get_genre(&self) -> &[GenreProperty] {
659 self.r#genre.as_slice()
660 }
661 fn take_genre(&mut self) -> Vec<GenreProperty> {
662 std::mem::take(&mut self.r#genre)
663 }
664 fn get_has_part(&self) -> &[HasPartProperty] {
665 self.r#has_part.as_slice()
666 }
667 fn take_has_part(&mut self) -> Vec<HasPartProperty> {
668 std::mem::take(&mut self.r#has_part)
669 }
670 fn get_headline(&self) -> &[HeadlineProperty] {
671 self.r#headline.as_slice()
672 }
673 fn take_headline(&mut self) -> Vec<HeadlineProperty> {
674 std::mem::take(&mut self.r#headline)
675 }
676 fn get_in_language(&self) -> &[InLanguageProperty] {
677 self.r#in_language.as_slice()
678 }
679 fn take_in_language(&mut self) -> Vec<InLanguageProperty> {
680 std::mem::take(&mut self.r#in_language)
681 }
682 fn get_interaction_statistic(&self) -> &[InteractionStatisticProperty] {
683 self.r#interaction_statistic.as_slice()
684 }
685 fn take_interaction_statistic(&mut self) -> Vec<InteractionStatisticProperty> {
686 std::mem::take(&mut self.r#interaction_statistic)
687 }
688 fn get_interactivity_type(&self) -> &[InteractivityTypeProperty] {
689 self.r#interactivity_type.as_slice()
690 }
691 fn take_interactivity_type(&mut self) -> Vec<InteractivityTypeProperty> {
692 std::mem::take(&mut self.r#interactivity_type)
693 }
694 fn get_interpreted_as_claim(&self) -> &[InterpretedAsClaimProperty] {
695 self.r#interpreted_as_claim.as_slice()
696 }
697 fn take_interpreted_as_claim(&mut self) -> Vec<InterpretedAsClaimProperty> {
698 std::mem::take(&mut self.r#interpreted_as_claim)
699 }
700 fn get_is_accessible_for_free(&self) -> &[IsAccessibleForFreeProperty] {
701 self.r#is_accessible_for_free.as_slice()
702 }
703 fn take_is_accessible_for_free(&mut self) -> Vec<IsAccessibleForFreeProperty> {
704 std::mem::take(&mut self.r#is_accessible_for_free)
705 }
706 fn get_is_based_on(&self) -> &[IsBasedOnProperty] {
707 self.r#is_based_on.as_slice()
708 }
709 fn take_is_based_on(&mut self) -> Vec<IsBasedOnProperty> {
710 std::mem::take(&mut self.r#is_based_on)
711 }
712 fn get_is_based_on_url(&self) -> &[IsBasedOnUrlProperty] {
713 self.r#is_based_on_url.as_slice()
714 }
715 fn take_is_based_on_url(&mut self) -> Vec<IsBasedOnUrlProperty> {
716 std::mem::take(&mut self.r#is_based_on_url)
717 }
718 fn get_is_family_friendly(&self) -> &[IsFamilyFriendlyProperty] {
719 self.r#is_family_friendly.as_slice()
720 }
721 fn take_is_family_friendly(&mut self) -> Vec<IsFamilyFriendlyProperty> {
722 std::mem::take(&mut self.r#is_family_friendly)
723 }
724 fn get_is_part_of(&self) -> &[IsPartOfProperty] {
725 self.r#is_part_of.as_slice()
726 }
727 fn take_is_part_of(&mut self) -> Vec<IsPartOfProperty> {
728 std::mem::take(&mut self.r#is_part_of)
729 }
730 fn get_keywords(&self) -> &[KeywordsProperty] {
731 self.r#keywords.as_slice()
732 }
733 fn take_keywords(&mut self) -> Vec<KeywordsProperty> {
734 std::mem::take(&mut self.r#keywords)
735 }
736 fn get_learning_resource_type(&self) -> &[LearningResourceTypeProperty] {
737 self.r#learning_resource_type.as_slice()
738 }
739 fn take_learning_resource_type(&mut self) -> Vec<LearningResourceTypeProperty> {
740 std::mem::take(&mut self.r#learning_resource_type)
741 }
742 fn get_license(&self) -> &[LicenseProperty] {
743 self.r#license.as_slice()
744 }
745 fn take_license(&mut self) -> Vec<LicenseProperty> {
746 std::mem::take(&mut self.r#license)
747 }
748 fn get_location_created(&self) -> &[LocationCreatedProperty] {
749 self.r#location_created.as_slice()
750 }
751 fn take_location_created(&mut self) -> Vec<LocationCreatedProperty> {
752 std::mem::take(&mut self.r#location_created)
753 }
754 fn get_main_entity(&self) -> &[MainEntityProperty] {
755 self.r#main_entity.as_slice()
756 }
757 fn take_main_entity(&mut self) -> Vec<MainEntityProperty> {
758 std::mem::take(&mut self.r#main_entity)
759 }
760 fn get_maintainer(&self) -> &[MaintainerProperty] {
761 self.r#maintainer.as_slice()
762 }
763 fn take_maintainer(&mut self) -> Vec<MaintainerProperty> {
764 std::mem::take(&mut self.r#maintainer)
765 }
766 fn get_material(&self) -> &[MaterialProperty] {
767 self.r#material.as_slice()
768 }
769 fn take_material(&mut self) -> Vec<MaterialProperty> {
770 std::mem::take(&mut self.r#material)
771 }
772 fn get_material_extent(&self) -> &[MaterialExtentProperty] {
773 self.r#material_extent.as_slice()
774 }
775 fn take_material_extent(&mut self) -> Vec<MaterialExtentProperty> {
776 std::mem::take(&mut self.r#material_extent)
777 }
778 fn get_mentions(&self) -> &[MentionsProperty] {
779 self.r#mentions.as_slice()
780 }
781 fn take_mentions(&mut self) -> Vec<MentionsProperty> {
782 std::mem::take(&mut self.r#mentions)
783 }
784 fn get_offers(&self) -> &[OffersProperty] {
785 self.r#offers.as_slice()
786 }
787 fn take_offers(&mut self) -> Vec<OffersProperty> {
788 std::mem::take(&mut self.r#offers)
789 }
790 fn get_pattern(&self) -> &[PatternProperty] {
791 self.r#pattern.as_slice()
792 }
793 fn take_pattern(&mut self) -> Vec<PatternProperty> {
794 std::mem::take(&mut self.r#pattern)
795 }
796 fn get_position(&self) -> &[PositionProperty] {
797 self.r#position.as_slice()
798 }
799 fn take_position(&mut self) -> Vec<PositionProperty> {
800 std::mem::take(&mut self.r#position)
801 }
802 fn get_producer(&self) -> &[ProducerProperty] {
803 self.r#producer.as_slice()
804 }
805 fn take_producer(&mut self) -> Vec<ProducerProperty> {
806 std::mem::take(&mut self.r#producer)
807 }
808 fn get_provider(&self) -> &[ProviderProperty] {
809 self.r#provider.as_slice()
810 }
811 fn take_provider(&mut self) -> Vec<ProviderProperty> {
812 std::mem::take(&mut self.r#provider)
813 }
814 fn get_publication(&self) -> &[PublicationProperty] {
815 self.r#publication.as_slice()
816 }
817 fn take_publication(&mut self) -> Vec<PublicationProperty> {
818 std::mem::take(&mut self.r#publication)
819 }
820 fn get_publisher(&self) -> &[PublisherProperty] {
821 self.r#publisher.as_slice()
822 }
823 fn take_publisher(&mut self) -> Vec<PublisherProperty> {
824 std::mem::take(&mut self.r#publisher)
825 }
826 fn get_publisher_imprint(&self) -> &[PublisherImprintProperty] {
827 self.r#publisher_imprint.as_slice()
828 }
829 fn take_publisher_imprint(&mut self) -> Vec<PublisherImprintProperty> {
830 std::mem::take(&mut self.r#publisher_imprint)
831 }
832 fn get_publishing_principles(&self) -> &[PublishingPrinciplesProperty] {
833 self.r#publishing_principles.as_slice()
834 }
835 fn take_publishing_principles(&mut self) -> Vec<PublishingPrinciplesProperty> {
836 std::mem::take(&mut self.r#publishing_principles)
837 }
838 fn get_recorded_at(&self) -> &[RecordedAtProperty] {
839 self.r#recorded_at.as_slice()
840 }
841 fn take_recorded_at(&mut self) -> Vec<RecordedAtProperty> {
842 std::mem::take(&mut self.r#recorded_at)
843 }
844 fn get_released_event(&self) -> &[ReleasedEventProperty] {
845 self.r#released_event.as_slice()
846 }
847 fn take_released_event(&mut self) -> Vec<ReleasedEventProperty> {
848 std::mem::take(&mut self.r#released_event)
849 }
850 fn get_review(&self) -> &[ReviewProperty] {
851 self.r#review.as_slice()
852 }
853 fn take_review(&mut self) -> Vec<ReviewProperty> {
854 std::mem::take(&mut self.r#review)
855 }
856 fn get_reviews(&self) -> &[ReviewsProperty] {
857 self.r#reviews.as_slice()
858 }
859 fn take_reviews(&mut self) -> Vec<ReviewsProperty> {
860 std::mem::take(&mut self.r#reviews)
861 }
862 fn get_schema_version(&self) -> &[SchemaVersionProperty] {
863 self.r#schema_version.as_slice()
864 }
865 fn take_schema_version(&mut self) -> Vec<SchemaVersionProperty> {
866 std::mem::take(&mut self.r#schema_version)
867 }
868 fn get_sd_date_published(&self) -> &[SdDatePublishedProperty] {
869 self.r#sd_date_published.as_slice()
870 }
871 fn take_sd_date_published(&mut self) -> Vec<SdDatePublishedProperty> {
872 std::mem::take(&mut self.r#sd_date_published)
873 }
874 fn get_sd_license(&self) -> &[SdLicenseProperty] {
875 self.r#sd_license.as_slice()
876 }
877 fn take_sd_license(&mut self) -> Vec<SdLicenseProperty> {
878 std::mem::take(&mut self.r#sd_license)
879 }
880 fn get_sd_publisher(&self) -> &[SdPublisherProperty] {
881 self.r#sd_publisher.as_slice()
882 }
883 fn take_sd_publisher(&mut self) -> Vec<SdPublisherProperty> {
884 std::mem::take(&mut self.r#sd_publisher)
885 }
886 fn get_size(&self) -> &[SizeProperty] {
887 self.r#size.as_slice()
888 }
889 fn take_size(&mut self) -> Vec<SizeProperty> {
890 std::mem::take(&mut self.r#size)
891 }
892 fn get_source_organization(&self) -> &[SourceOrganizationProperty] {
893 self.r#source_organization.as_slice()
894 }
895 fn take_source_organization(&mut self) -> Vec<SourceOrganizationProperty> {
896 std::mem::take(&mut self.r#source_organization)
897 }
898 fn get_spatial(&self) -> &[SpatialProperty] {
899 self.r#spatial.as_slice()
900 }
901 fn take_spatial(&mut self) -> Vec<SpatialProperty> {
902 std::mem::take(&mut self.r#spatial)
903 }
904 fn get_spatial_coverage(&self) -> &[SpatialCoverageProperty] {
905 self.r#spatial_coverage.as_slice()
906 }
907 fn take_spatial_coverage(&mut self) -> Vec<SpatialCoverageProperty> {
908 std::mem::take(&mut self.r#spatial_coverage)
909 }
910 fn get_sponsor(&self) -> &[SponsorProperty] {
911 self.r#sponsor.as_slice()
912 }
913 fn take_sponsor(&mut self) -> Vec<SponsorProperty> {
914 std::mem::take(&mut self.r#sponsor)
915 }
916 fn get_teaches(&self) -> &[TeachesProperty] {
917 self.r#teaches.as_slice()
918 }
919 fn take_teaches(&mut self) -> Vec<TeachesProperty> {
920 std::mem::take(&mut self.r#teaches)
921 }
922 fn get_temporal(&self) -> &[TemporalProperty] {
923 self.r#temporal.as_slice()
924 }
925 fn take_temporal(&mut self) -> Vec<TemporalProperty> {
926 std::mem::take(&mut self.r#temporal)
927 }
928 fn get_temporal_coverage(&self) -> &[TemporalCoverageProperty] {
929 self.r#temporal_coverage.as_slice()
930 }
931 fn take_temporal_coverage(&mut self) -> Vec<TemporalCoverageProperty> {
932 std::mem::take(&mut self.r#temporal_coverage)
933 }
934 fn get_text(&self) -> &[TextProperty] {
935 self.r#text.as_slice()
936 }
937 fn take_text(&mut self) -> Vec<TextProperty> {
938 std::mem::take(&mut self.r#text)
939 }
940 fn get_thumbnail(&self) -> &[ThumbnailProperty] {
941 self.r#thumbnail.as_slice()
942 }
943 fn take_thumbnail(&mut self) -> Vec<ThumbnailProperty> {
944 std::mem::take(&mut self.r#thumbnail)
945 }
946 fn get_thumbnail_url(&self) -> &[ThumbnailUrlProperty] {
947 self.r#thumbnail_url.as_slice()
948 }
949 fn take_thumbnail_url(&mut self) -> Vec<ThumbnailUrlProperty> {
950 std::mem::take(&mut self.r#thumbnail_url)
951 }
952 fn get_time_required(&self) -> &[TimeRequiredProperty] {
953 self.r#time_required.as_slice()
954 }
955 fn take_time_required(&mut self) -> Vec<TimeRequiredProperty> {
956 std::mem::take(&mut self.r#time_required)
957 }
958 fn get_translation_of_work(&self) -> &[TranslationOfWorkProperty] {
959 self.r#translation_of_work.as_slice()
960 }
961 fn take_translation_of_work(&mut self) -> Vec<TranslationOfWorkProperty> {
962 std::mem::take(&mut self.r#translation_of_work)
963 }
964 fn get_translator(&self) -> &[TranslatorProperty] {
965 self.r#translator.as_slice()
966 }
967 fn take_translator(&mut self) -> Vec<TranslatorProperty> {
968 std::mem::take(&mut self.r#translator)
969 }
970 fn get_typical_age_range(&self) -> &[TypicalAgeRangeProperty] {
971 self.r#typical_age_range.as_slice()
972 }
973 fn take_typical_age_range(&mut self) -> Vec<TypicalAgeRangeProperty> {
974 std::mem::take(&mut self.r#typical_age_range)
975 }
976 fn get_usage_info(&self) -> &[UsageInfoProperty] {
977 self.r#usage_info.as_slice()
978 }
979 fn take_usage_info(&mut self) -> Vec<UsageInfoProperty> {
980 std::mem::take(&mut self.r#usage_info)
981 }
982 fn get_version(&self) -> &[VersionProperty] {
983 self.r#version.as_slice()
984 }
985 fn take_version(&mut self) -> Vec<VersionProperty> {
986 std::mem::take(&mut self.r#version)
987 }
988 fn get_video(&self) -> &[VideoProperty] {
989 self.r#video.as_slice()
990 }
991 fn take_video(&mut self) -> Vec<VideoProperty> {
992 std::mem::take(&mut self.r#video)
993 }
994 fn get_work_example(&self) -> &[WorkExampleProperty] {
995 self.r#work_example.as_slice()
996 }
997 fn take_work_example(&mut self) -> Vec<WorkExampleProperty> {
998 std::mem::take(&mut self.r#work_example)
999 }
1000 fn get_work_translation(&self) -> &[WorkTranslationProperty] {
1001 self.r#work_translation.as_slice()
1002 }
1003 fn take_work_translation(&mut self) -> Vec<WorkTranslationProperty> {
1004 std::mem::take(&mut self.r#work_translation)
1005 }
1006}
1007impl CreativeWorkSeasonTrait for TvSeason {
1008 fn get_actor(&self) -> &[ActorProperty] {
1009 self.r#actor.as_slice()
1010 }
1011 fn take_actor(&mut self) -> Vec<ActorProperty> {
1012 std::mem::take(&mut self.r#actor)
1013 }
1014 fn get_director(&self) -> &[DirectorProperty] {
1015 self.r#director.as_slice()
1016 }
1017 fn take_director(&mut self) -> Vec<DirectorProperty> {
1018 std::mem::take(&mut self.r#director)
1019 }
1020 fn get_end_date(&self) -> &[EndDateProperty] {
1021 self.r#end_date.as_slice()
1022 }
1023 fn take_end_date(&mut self) -> Vec<EndDateProperty> {
1024 std::mem::take(&mut self.r#end_date)
1025 }
1026 fn get_episode(&self) -> &[EpisodeProperty] {
1027 self.r#episode.as_slice()
1028 }
1029 fn take_episode(&mut self) -> Vec<EpisodeProperty> {
1030 std::mem::take(&mut self.r#episode)
1031 }
1032 fn get_episodes(&self) -> &[EpisodesProperty] {
1033 self.r#episodes.as_slice()
1034 }
1035 fn take_episodes(&mut self) -> Vec<EpisodesProperty> {
1036 std::mem::take(&mut self.r#episodes)
1037 }
1038 fn get_number_of_episodes(&self) -> &[NumberOfEpisodesProperty] {
1039 self.r#number_of_episodes.as_slice()
1040 }
1041 fn take_number_of_episodes(&mut self) -> Vec<NumberOfEpisodesProperty> {
1042 std::mem::take(&mut self.r#number_of_episodes)
1043 }
1044 fn get_part_of_series(&self) -> &[PartOfSeriesProperty] {
1045 self.r#part_of_series.as_slice()
1046 }
1047 fn take_part_of_series(&mut self) -> Vec<PartOfSeriesProperty> {
1048 std::mem::take(&mut self.r#part_of_series)
1049 }
1050 fn get_production_company(&self) -> &[ProductionCompanyProperty] {
1051 self.r#production_company.as_slice()
1052 }
1053 fn take_production_company(&mut self) -> Vec<ProductionCompanyProperty> {
1054 std::mem::take(&mut self.r#production_company)
1055 }
1056 fn get_season_number(&self) -> &[SeasonNumberProperty] {
1057 self.r#season_number.as_slice()
1058 }
1059 fn take_season_number(&mut self) -> Vec<SeasonNumberProperty> {
1060 std::mem::take(&mut self.r#season_number)
1061 }
1062 fn get_start_date(&self) -> &[StartDateProperty] {
1063 self.r#start_date.as_slice()
1064 }
1065 fn take_start_date(&mut self) -> Vec<StartDateProperty> {
1066 std::mem::take(&mut self.r#start_date)
1067 }
1068 fn get_trailer(&self) -> &[TrailerProperty] {
1069 self.r#trailer.as_slice()
1070 }
1071 fn take_trailer(&mut self) -> Vec<TrailerProperty> {
1072 std::mem::take(&mut self.r#trailer)
1073 }
1074}
1075impl ThingTrait for TvSeason {
1076 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
1077 self.r#additional_type.as_slice()
1078 }
1079 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
1080 std::mem::take(&mut self.r#additional_type)
1081 }
1082 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
1083 self.r#alternate_name.as_slice()
1084 }
1085 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
1086 std::mem::take(&mut self.r#alternate_name)
1087 }
1088 fn get_description(&self) -> &[DescriptionProperty] {
1089 self.r#description.as_slice()
1090 }
1091 fn take_description(&mut self) -> Vec<DescriptionProperty> {
1092 std::mem::take(&mut self.r#description)
1093 }
1094 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
1095 self.r#disambiguating_description.as_slice()
1096 }
1097 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
1098 std::mem::take(&mut self.r#disambiguating_description)
1099 }
1100 fn get_identifier(&self) -> &[IdentifierProperty] {
1101 self.r#identifier.as_slice()
1102 }
1103 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
1104 std::mem::take(&mut self.r#identifier)
1105 }
1106 fn get_image(&self) -> &[ImageProperty] {
1107 self.r#image.as_slice()
1108 }
1109 fn take_image(&mut self) -> Vec<ImageProperty> {
1110 std::mem::take(&mut self.r#image)
1111 }
1112 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
1113 self.r#main_entity_of_page.as_slice()
1114 }
1115 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
1116 std::mem::take(&mut self.r#main_entity_of_page)
1117 }
1118 fn get_name(&self) -> &[NameProperty] {
1119 self.r#name.as_slice()
1120 }
1121 fn take_name(&mut self) -> Vec<NameProperty> {
1122 std::mem::take(&mut self.r#name)
1123 }
1124 fn get_potential_action(&self) -> &[PotentialActionProperty] {
1125 self.r#potential_action.as_slice()
1126 }
1127 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
1128 std::mem::take(&mut self.r#potential_action)
1129 }
1130 fn get_same_as(&self) -> &[SameAsProperty] {
1131 self.r#same_as.as_slice()
1132 }
1133 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
1134 std::mem::take(&mut self.r#same_as)
1135 }
1136 fn get_subject_of(&self) -> &[SubjectOfProperty] {
1137 self.r#subject_of.as_slice()
1138 }
1139 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
1140 std::mem::take(&mut self.r#subject_of)
1141 }
1142 fn get_url(&self) -> &[UrlProperty] {
1143 self.r#url.as_slice()
1144 }
1145 fn take_url(&mut self) -> Vec<UrlProperty> {
1146 std::mem::take(&mut self.r#url)
1147 }
1148}
1149#[cfg(feature = "serde")]
1150mod serde {
1151 use std::{fmt, fmt::Formatter};
1152
1153 use ::serde::{
1154 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
1155 };
1156
1157 use super::*;
1158 impl Serialize for TvSeason {
1159 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1160 where
1161 S: Serializer,
1162 {
1163 let len: usize = [
1164 !Vec::is_empty(&self.r#country_of_origin) as usize,
1165 !Vec::is_empty(&self.r#part_of_tv_series) as usize,
1166 !Vec::is_empty(&self.r#title_eidr) as usize,
1167 !Vec::is_empty(&self.r#about) as usize,
1168 !Vec::is_empty(&self.r#abstract) as usize,
1169 !Vec::is_empty(&self.r#access_mode) as usize,
1170 !Vec::is_empty(&self.r#access_mode_sufficient) as usize,
1171 !Vec::is_empty(&self.r#accessibility_api) as usize,
1172 !Vec::is_empty(&self.r#accessibility_control) as usize,
1173 !Vec::is_empty(&self.r#accessibility_feature) as usize,
1174 !Vec::is_empty(&self.r#accessibility_hazard) as usize,
1175 !Vec::is_empty(&self.r#accessibility_summary) as usize,
1176 !Vec::is_empty(&self.r#accountable_person) as usize,
1177 !Vec::is_empty(&self.r#acquire_license_page) as usize,
1178 !Vec::is_empty(&self.r#aggregate_rating) as usize,
1179 !Vec::is_empty(&self.r#alternative_headline) as usize,
1180 !Vec::is_empty(&self.r#archived_at) as usize,
1181 !Vec::is_empty(&self.r#assesses) as usize,
1182 !Vec::is_empty(&self.r#associated_media) as usize,
1183 !Vec::is_empty(&self.r#audience) as usize,
1184 !Vec::is_empty(&self.r#audio) as usize,
1185 !Vec::is_empty(&self.r#author) as usize,
1186 !Vec::is_empty(&self.r#award) as usize,
1187 !Vec::is_empty(&self.r#awards) as usize,
1188 !Vec::is_empty(&self.r#character) as usize,
1189 !Vec::is_empty(&self.r#citation) as usize,
1190 !Vec::is_empty(&self.r#comment) as usize,
1191 !Vec::is_empty(&self.r#comment_count) as usize,
1192 !Vec::is_empty(&self.r#conditions_of_access) as usize,
1193 !Vec::is_empty(&self.r#content_location) as usize,
1194 !Vec::is_empty(&self.r#content_rating) as usize,
1195 !Vec::is_empty(&self.r#content_reference_time) as usize,
1196 !Vec::is_empty(&self.r#contributor) as usize,
1197 !Vec::is_empty(&self.r#copyright_holder) as usize,
1198 !Vec::is_empty(&self.r#copyright_notice) as usize,
1199 !Vec::is_empty(&self.r#copyright_year) as usize,
1200 !Vec::is_empty(&self.r#correction) as usize,
1201 !Vec::is_empty(&self.r#creative_work_status) as usize,
1202 !Vec::is_empty(&self.r#creator) as usize,
1203 !Vec::is_empty(&self.r#credit_text) as usize,
1204 !Vec::is_empty(&self.r#date_created) as usize,
1205 !Vec::is_empty(&self.r#date_modified) as usize,
1206 !Vec::is_empty(&self.r#date_published) as usize,
1207 !Vec::is_empty(&self.r#discussion_url) as usize,
1208 !Vec::is_empty(&self.r#edit_eidr) as usize,
1209 !Vec::is_empty(&self.r#editor) as usize,
1210 !Vec::is_empty(&self.r#educational_alignment) as usize,
1211 !Vec::is_empty(&self.r#educational_level) as usize,
1212 !Vec::is_empty(&self.r#educational_use) as usize,
1213 !Vec::is_empty(&self.r#encoding) as usize,
1214 !Vec::is_empty(&self.r#encoding_format) as usize,
1215 !Vec::is_empty(&self.r#encodings) as usize,
1216 !Vec::is_empty(&self.r#example_of_work) as usize,
1217 !Vec::is_empty(&self.r#expires) as usize,
1218 !Vec::is_empty(&self.r#file_format) as usize,
1219 !Vec::is_empty(&self.r#funder) as usize,
1220 !Vec::is_empty(&self.r#funding) as usize,
1221 !Vec::is_empty(&self.r#genre) as usize,
1222 !Vec::is_empty(&self.r#has_part) as usize,
1223 !Vec::is_empty(&self.r#headline) as usize,
1224 !Vec::is_empty(&self.r#in_language) as usize,
1225 !Vec::is_empty(&self.r#interaction_statistic) as usize,
1226 !Vec::is_empty(&self.r#interactivity_type) as usize,
1227 !Vec::is_empty(&self.r#interpreted_as_claim) as usize,
1228 !Vec::is_empty(&self.r#is_accessible_for_free) as usize,
1229 !Vec::is_empty(&self.r#is_based_on) as usize,
1230 !Vec::is_empty(&self.r#is_based_on_url) as usize,
1231 !Vec::is_empty(&self.r#is_family_friendly) as usize,
1232 !Vec::is_empty(&self.r#is_part_of) as usize,
1233 !Vec::is_empty(&self.r#keywords) as usize,
1234 !Vec::is_empty(&self.r#learning_resource_type) as usize,
1235 !Vec::is_empty(&self.r#license) as usize,
1236 !Vec::is_empty(&self.r#location_created) as usize,
1237 !Vec::is_empty(&self.r#main_entity) as usize,
1238 !Vec::is_empty(&self.r#maintainer) as usize,
1239 !Vec::is_empty(&self.r#material) as usize,
1240 !Vec::is_empty(&self.r#material_extent) as usize,
1241 !Vec::is_empty(&self.r#mentions) as usize,
1242 !Vec::is_empty(&self.r#offers) as usize,
1243 !Vec::is_empty(&self.r#pattern) as usize,
1244 !Vec::is_empty(&self.r#position) as usize,
1245 !Vec::is_empty(&self.r#producer) as usize,
1246 !Vec::is_empty(&self.r#provider) as usize,
1247 !Vec::is_empty(&self.r#publication) as usize,
1248 !Vec::is_empty(&self.r#publisher) as usize,
1249 !Vec::is_empty(&self.r#publisher_imprint) as usize,
1250 !Vec::is_empty(&self.r#publishing_principles) as usize,
1251 !Vec::is_empty(&self.r#recorded_at) as usize,
1252 !Vec::is_empty(&self.r#released_event) as usize,
1253 !Vec::is_empty(&self.r#review) as usize,
1254 !Vec::is_empty(&self.r#reviews) as usize,
1255 !Vec::is_empty(&self.r#schema_version) as usize,
1256 !Vec::is_empty(&self.r#sd_date_published) as usize,
1257 !Vec::is_empty(&self.r#sd_license) as usize,
1258 !Vec::is_empty(&self.r#sd_publisher) as usize,
1259 !Vec::is_empty(&self.r#size) as usize,
1260 !Vec::is_empty(&self.r#source_organization) as usize,
1261 !Vec::is_empty(&self.r#spatial) as usize,
1262 !Vec::is_empty(&self.r#spatial_coverage) as usize,
1263 !Vec::is_empty(&self.r#sponsor) as usize,
1264 !Vec::is_empty(&self.r#teaches) as usize,
1265 !Vec::is_empty(&self.r#temporal) as usize,
1266 !Vec::is_empty(&self.r#temporal_coverage) as usize,
1267 !Vec::is_empty(&self.r#text) as usize,
1268 !Vec::is_empty(&self.r#thumbnail) as usize,
1269 !Vec::is_empty(&self.r#thumbnail_url) as usize,
1270 !Vec::is_empty(&self.r#time_required) as usize,
1271 !Vec::is_empty(&self.r#translation_of_work) as usize,
1272 !Vec::is_empty(&self.r#translator) as usize,
1273 !Vec::is_empty(&self.r#typical_age_range) as usize,
1274 !Vec::is_empty(&self.r#usage_info) as usize,
1275 !Vec::is_empty(&self.r#version) as usize,
1276 !Vec::is_empty(&self.r#video) as usize,
1277 !Vec::is_empty(&self.r#work_example) as usize,
1278 !Vec::is_empty(&self.r#work_translation) as usize,
1279 !Vec::is_empty(&self.r#actor) as usize,
1280 !Vec::is_empty(&self.r#director) as usize,
1281 !Vec::is_empty(&self.r#end_date) as usize,
1282 !Vec::is_empty(&self.r#episode) as usize,
1283 !Vec::is_empty(&self.r#episodes) as usize,
1284 !Vec::is_empty(&self.r#number_of_episodes) as usize,
1285 !Vec::is_empty(&self.r#part_of_series) as usize,
1286 !Vec::is_empty(&self.r#production_company) as usize,
1287 !Vec::is_empty(&self.r#season_number) as usize,
1288 !Vec::is_empty(&self.r#start_date) as usize,
1289 !Vec::is_empty(&self.r#trailer) as usize,
1290 !Vec::is_empty(&self.r#additional_type) as usize,
1291 !Vec::is_empty(&self.r#alternate_name) as usize,
1292 !Vec::is_empty(&self.r#description) as usize,
1293 !Vec::is_empty(&self.r#disambiguating_description) as usize,
1294 !Vec::is_empty(&self.r#identifier) as usize,
1295 !Vec::is_empty(&self.r#image) as usize,
1296 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
1297 !Vec::is_empty(&self.r#name) as usize,
1298 !Vec::is_empty(&self.r#potential_action) as usize,
1299 !Vec::is_empty(&self.r#same_as) as usize,
1300 !Vec::is_empty(&self.r#subject_of) as usize,
1301 !Vec::is_empty(&self.r#url) as usize,
1302 ]
1303 .iter()
1304 .sum();
1305 let mut serialize_struct = Serializer::serialize_struct(serializer, "TvSeason", len)?;
1306 if !Vec::is_empty(&self.r#country_of_origin) {
1307 serialize_struct.serialize_field("countryOfOrigin", {
1308 struct SerializeWith<'a>(&'a Vec<CountryOfOriginProperty>);
1309 impl<'a> Serialize for SerializeWith<'a> {
1310 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1311 where
1312 S: Serializer,
1313 {
1314 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1315 self.0, serializer,
1316 )
1317 }
1318 }
1319 &SerializeWith(&self.r#country_of_origin)
1320 })?;
1321 } else {
1322 serialize_struct.skip_field("countryOfOrigin")?;
1323 }
1324 if !Vec::is_empty(&self.r#part_of_tv_series) {
1325 serialize_struct.serialize_field("partOfTVSeries", {
1326 struct SerializeWith<'a>(&'a Vec<PartOfTvSeriesProperty>);
1327 impl<'a> Serialize for SerializeWith<'a> {
1328 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1329 where
1330 S: Serializer,
1331 {
1332 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1333 self.0, serializer,
1334 )
1335 }
1336 }
1337 &SerializeWith(&self.r#part_of_tv_series)
1338 })?;
1339 } else {
1340 serialize_struct.skip_field("partOfTVSeries")?;
1341 }
1342 if !Vec::is_empty(&self.r#title_eidr) {
1343 serialize_struct.serialize_field("titleEIDR", {
1344 struct SerializeWith<'a>(&'a Vec<TitleEidrProperty>);
1345 impl<'a> Serialize for SerializeWith<'a> {
1346 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1347 where
1348 S: Serializer,
1349 {
1350 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1351 self.0, serializer,
1352 )
1353 }
1354 }
1355 &SerializeWith(&self.r#title_eidr)
1356 })?;
1357 } else {
1358 serialize_struct.skip_field("titleEIDR")?;
1359 }
1360 if !Vec::is_empty(&self.r#about) {
1361 serialize_struct.serialize_field("about", {
1362 struct SerializeWith<'a>(&'a Vec<AboutProperty>);
1363 impl<'a> Serialize for SerializeWith<'a> {
1364 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1365 where
1366 S: Serializer,
1367 {
1368 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1369 self.0, serializer,
1370 )
1371 }
1372 }
1373 &SerializeWith(&self.r#about)
1374 })?;
1375 } else {
1376 serialize_struct.skip_field("about")?;
1377 }
1378 if !Vec::is_empty(&self.r#abstract) {
1379 serialize_struct.serialize_field("abstract", {
1380 struct SerializeWith<'a>(&'a Vec<AbstractProperty>);
1381 impl<'a> Serialize for SerializeWith<'a> {
1382 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1383 where
1384 S: Serializer,
1385 {
1386 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1387 self.0, serializer,
1388 )
1389 }
1390 }
1391 &SerializeWith(&self.r#abstract)
1392 })?;
1393 } else {
1394 serialize_struct.skip_field("abstract")?;
1395 }
1396 if !Vec::is_empty(&self.r#access_mode) {
1397 serialize_struct.serialize_field("accessMode", {
1398 struct SerializeWith<'a>(&'a Vec<AccessModeProperty>);
1399 impl<'a> Serialize for SerializeWith<'a> {
1400 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1401 where
1402 S: Serializer,
1403 {
1404 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1405 self.0, serializer,
1406 )
1407 }
1408 }
1409 &SerializeWith(&self.r#access_mode)
1410 })?;
1411 } else {
1412 serialize_struct.skip_field("accessMode")?;
1413 }
1414 if !Vec::is_empty(&self.r#access_mode_sufficient) {
1415 serialize_struct.serialize_field("accessModeSufficient", {
1416 struct SerializeWith<'a>(&'a Vec<AccessModeSufficientProperty>);
1417 impl<'a> Serialize for SerializeWith<'a> {
1418 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1419 where
1420 S: Serializer,
1421 {
1422 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1423 self.0, serializer,
1424 )
1425 }
1426 }
1427 &SerializeWith(&self.r#access_mode_sufficient)
1428 })?;
1429 } else {
1430 serialize_struct.skip_field("accessModeSufficient")?;
1431 }
1432 if !Vec::is_empty(&self.r#accessibility_api) {
1433 serialize_struct.serialize_field("accessibilityAPI", {
1434 struct SerializeWith<'a>(&'a Vec<AccessibilityApiProperty>);
1435 impl<'a> Serialize for SerializeWith<'a> {
1436 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1437 where
1438 S: Serializer,
1439 {
1440 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1441 self.0, serializer,
1442 )
1443 }
1444 }
1445 &SerializeWith(&self.r#accessibility_api)
1446 })?;
1447 } else {
1448 serialize_struct.skip_field("accessibilityAPI")?;
1449 }
1450 if !Vec::is_empty(&self.r#accessibility_control) {
1451 serialize_struct.serialize_field("accessibilityControl", {
1452 struct SerializeWith<'a>(&'a Vec<AccessibilityControlProperty>);
1453 impl<'a> Serialize for SerializeWith<'a> {
1454 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1455 where
1456 S: Serializer,
1457 {
1458 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1459 self.0, serializer,
1460 )
1461 }
1462 }
1463 &SerializeWith(&self.r#accessibility_control)
1464 })?;
1465 } else {
1466 serialize_struct.skip_field("accessibilityControl")?;
1467 }
1468 if !Vec::is_empty(&self.r#accessibility_feature) {
1469 serialize_struct.serialize_field("accessibilityFeature", {
1470 struct SerializeWith<'a>(&'a Vec<AccessibilityFeatureProperty>);
1471 impl<'a> Serialize for SerializeWith<'a> {
1472 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1473 where
1474 S: Serializer,
1475 {
1476 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1477 self.0, serializer,
1478 )
1479 }
1480 }
1481 &SerializeWith(&self.r#accessibility_feature)
1482 })?;
1483 } else {
1484 serialize_struct.skip_field("accessibilityFeature")?;
1485 }
1486 if !Vec::is_empty(&self.r#accessibility_hazard) {
1487 serialize_struct.serialize_field("accessibilityHazard", {
1488 struct SerializeWith<'a>(&'a Vec<AccessibilityHazardProperty>);
1489 impl<'a> Serialize for SerializeWith<'a> {
1490 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1491 where
1492 S: Serializer,
1493 {
1494 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1495 self.0, serializer,
1496 )
1497 }
1498 }
1499 &SerializeWith(&self.r#accessibility_hazard)
1500 })?;
1501 } else {
1502 serialize_struct.skip_field("accessibilityHazard")?;
1503 }
1504 if !Vec::is_empty(&self.r#accessibility_summary) {
1505 serialize_struct.serialize_field("accessibilitySummary", {
1506 struct SerializeWith<'a>(&'a Vec<AccessibilitySummaryProperty>);
1507 impl<'a> Serialize for SerializeWith<'a> {
1508 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1509 where
1510 S: Serializer,
1511 {
1512 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1513 self.0, serializer,
1514 )
1515 }
1516 }
1517 &SerializeWith(&self.r#accessibility_summary)
1518 })?;
1519 } else {
1520 serialize_struct.skip_field("accessibilitySummary")?;
1521 }
1522 if !Vec::is_empty(&self.r#accountable_person) {
1523 serialize_struct.serialize_field("accountablePerson", {
1524 struct SerializeWith<'a>(&'a Vec<AccountablePersonProperty>);
1525 impl<'a> Serialize for SerializeWith<'a> {
1526 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1527 where
1528 S: Serializer,
1529 {
1530 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1531 self.0, serializer,
1532 )
1533 }
1534 }
1535 &SerializeWith(&self.r#accountable_person)
1536 })?;
1537 } else {
1538 serialize_struct.skip_field("accountablePerson")?;
1539 }
1540 if !Vec::is_empty(&self.r#acquire_license_page) {
1541 serialize_struct.serialize_field("acquireLicensePage", {
1542 struct SerializeWith<'a>(&'a Vec<AcquireLicensePageProperty>);
1543 impl<'a> Serialize for SerializeWith<'a> {
1544 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1545 where
1546 S: Serializer,
1547 {
1548 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1549 self.0, serializer,
1550 )
1551 }
1552 }
1553 &SerializeWith(&self.r#acquire_license_page)
1554 })?;
1555 } else {
1556 serialize_struct.skip_field("acquireLicensePage")?;
1557 }
1558 if !Vec::is_empty(&self.r#aggregate_rating) {
1559 serialize_struct.serialize_field("aggregateRating", {
1560 struct SerializeWith<'a>(&'a Vec<AggregateRatingProperty>);
1561 impl<'a> Serialize for SerializeWith<'a> {
1562 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1563 where
1564 S: Serializer,
1565 {
1566 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1567 self.0, serializer,
1568 )
1569 }
1570 }
1571 &SerializeWith(&self.r#aggregate_rating)
1572 })?;
1573 } else {
1574 serialize_struct.skip_field("aggregateRating")?;
1575 }
1576 if !Vec::is_empty(&self.r#alternative_headline) {
1577 serialize_struct.serialize_field("alternativeHeadline", {
1578 struct SerializeWith<'a>(&'a Vec<AlternativeHeadlineProperty>);
1579 impl<'a> Serialize for SerializeWith<'a> {
1580 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1581 where
1582 S: Serializer,
1583 {
1584 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1585 self.0, serializer,
1586 )
1587 }
1588 }
1589 &SerializeWith(&self.r#alternative_headline)
1590 })?;
1591 } else {
1592 serialize_struct.skip_field("alternativeHeadline")?;
1593 }
1594 if !Vec::is_empty(&self.r#archived_at) {
1595 serialize_struct.serialize_field("archivedAt", {
1596 struct SerializeWith<'a>(&'a Vec<ArchivedAtProperty>);
1597 impl<'a> Serialize for SerializeWith<'a> {
1598 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1599 where
1600 S: Serializer,
1601 {
1602 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1603 self.0, serializer,
1604 )
1605 }
1606 }
1607 &SerializeWith(&self.r#archived_at)
1608 })?;
1609 } else {
1610 serialize_struct.skip_field("archivedAt")?;
1611 }
1612 if !Vec::is_empty(&self.r#assesses) {
1613 serialize_struct.serialize_field("assesses", {
1614 struct SerializeWith<'a>(&'a Vec<AssessesProperty>);
1615 impl<'a> Serialize for SerializeWith<'a> {
1616 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1617 where
1618 S: Serializer,
1619 {
1620 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1621 self.0, serializer,
1622 )
1623 }
1624 }
1625 &SerializeWith(&self.r#assesses)
1626 })?;
1627 } else {
1628 serialize_struct.skip_field("assesses")?;
1629 }
1630 if !Vec::is_empty(&self.r#associated_media) {
1631 serialize_struct.serialize_field("associatedMedia", {
1632 struct SerializeWith<'a>(&'a Vec<AssociatedMediaProperty>);
1633 impl<'a> Serialize for SerializeWith<'a> {
1634 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1635 where
1636 S: Serializer,
1637 {
1638 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1639 self.0, serializer,
1640 )
1641 }
1642 }
1643 &SerializeWith(&self.r#associated_media)
1644 })?;
1645 } else {
1646 serialize_struct.skip_field("associatedMedia")?;
1647 }
1648 if !Vec::is_empty(&self.r#audience) {
1649 serialize_struct.serialize_field("audience", {
1650 struct SerializeWith<'a>(&'a Vec<AudienceProperty>);
1651 impl<'a> Serialize for SerializeWith<'a> {
1652 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1653 where
1654 S: Serializer,
1655 {
1656 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1657 self.0, serializer,
1658 )
1659 }
1660 }
1661 &SerializeWith(&self.r#audience)
1662 })?;
1663 } else {
1664 serialize_struct.skip_field("audience")?;
1665 }
1666 if !Vec::is_empty(&self.r#audio) {
1667 serialize_struct.serialize_field("audio", {
1668 struct SerializeWith<'a>(&'a Vec<AudioProperty>);
1669 impl<'a> Serialize for SerializeWith<'a> {
1670 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1671 where
1672 S: Serializer,
1673 {
1674 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1675 self.0, serializer,
1676 )
1677 }
1678 }
1679 &SerializeWith(&self.r#audio)
1680 })?;
1681 } else {
1682 serialize_struct.skip_field("audio")?;
1683 }
1684 if !Vec::is_empty(&self.r#author) {
1685 serialize_struct.serialize_field("author", {
1686 struct SerializeWith<'a>(&'a Vec<AuthorProperty>);
1687 impl<'a> Serialize for SerializeWith<'a> {
1688 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1689 where
1690 S: Serializer,
1691 {
1692 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1693 self.0, serializer,
1694 )
1695 }
1696 }
1697 &SerializeWith(&self.r#author)
1698 })?;
1699 } else {
1700 serialize_struct.skip_field("author")?;
1701 }
1702 if !Vec::is_empty(&self.r#award) {
1703 serialize_struct.serialize_field("award", {
1704 struct SerializeWith<'a>(&'a Vec<AwardProperty>);
1705 impl<'a> Serialize for SerializeWith<'a> {
1706 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1707 where
1708 S: Serializer,
1709 {
1710 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1711 self.0, serializer,
1712 )
1713 }
1714 }
1715 &SerializeWith(&self.r#award)
1716 })?;
1717 } else {
1718 serialize_struct.skip_field("award")?;
1719 }
1720 if !Vec::is_empty(&self.r#awards) {
1721 serialize_struct.serialize_field("awards", {
1722 struct SerializeWith<'a>(&'a Vec<AwardsProperty>);
1723 impl<'a> Serialize for SerializeWith<'a> {
1724 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1725 where
1726 S: Serializer,
1727 {
1728 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1729 self.0, serializer,
1730 )
1731 }
1732 }
1733 &SerializeWith(&self.r#awards)
1734 })?;
1735 } else {
1736 serialize_struct.skip_field("awards")?;
1737 }
1738 if !Vec::is_empty(&self.r#character) {
1739 serialize_struct.serialize_field("character", {
1740 struct SerializeWith<'a>(&'a Vec<CharacterProperty>);
1741 impl<'a> Serialize for SerializeWith<'a> {
1742 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1743 where
1744 S: Serializer,
1745 {
1746 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1747 self.0, serializer,
1748 )
1749 }
1750 }
1751 &SerializeWith(&self.r#character)
1752 })?;
1753 } else {
1754 serialize_struct.skip_field("character")?;
1755 }
1756 if !Vec::is_empty(&self.r#citation) {
1757 serialize_struct.serialize_field("citation", {
1758 struct SerializeWith<'a>(&'a Vec<CitationProperty>);
1759 impl<'a> Serialize for SerializeWith<'a> {
1760 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1761 where
1762 S: Serializer,
1763 {
1764 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1765 self.0, serializer,
1766 )
1767 }
1768 }
1769 &SerializeWith(&self.r#citation)
1770 })?;
1771 } else {
1772 serialize_struct.skip_field("citation")?;
1773 }
1774 if !Vec::is_empty(&self.r#comment) {
1775 serialize_struct.serialize_field("comment", {
1776 struct SerializeWith<'a>(&'a Vec<CommentProperty>);
1777 impl<'a> Serialize for SerializeWith<'a> {
1778 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1779 where
1780 S: Serializer,
1781 {
1782 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1783 self.0, serializer,
1784 )
1785 }
1786 }
1787 &SerializeWith(&self.r#comment)
1788 })?;
1789 } else {
1790 serialize_struct.skip_field("comment")?;
1791 }
1792 if !Vec::is_empty(&self.r#comment_count) {
1793 serialize_struct.serialize_field("commentCount", {
1794 struct SerializeWith<'a>(&'a Vec<CommentCountProperty>);
1795 impl<'a> Serialize for SerializeWith<'a> {
1796 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1797 where
1798 S: Serializer,
1799 {
1800 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1801 self.0, serializer,
1802 )
1803 }
1804 }
1805 &SerializeWith(&self.r#comment_count)
1806 })?;
1807 } else {
1808 serialize_struct.skip_field("commentCount")?;
1809 }
1810 if !Vec::is_empty(&self.r#conditions_of_access) {
1811 serialize_struct.serialize_field("conditionsOfAccess", {
1812 struct SerializeWith<'a>(&'a Vec<ConditionsOfAccessProperty>);
1813 impl<'a> Serialize for SerializeWith<'a> {
1814 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1815 where
1816 S: Serializer,
1817 {
1818 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1819 self.0, serializer,
1820 )
1821 }
1822 }
1823 &SerializeWith(&self.r#conditions_of_access)
1824 })?;
1825 } else {
1826 serialize_struct.skip_field("conditionsOfAccess")?;
1827 }
1828 if !Vec::is_empty(&self.r#content_location) {
1829 serialize_struct.serialize_field("contentLocation", {
1830 struct SerializeWith<'a>(&'a Vec<ContentLocationProperty>);
1831 impl<'a> Serialize for SerializeWith<'a> {
1832 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1833 where
1834 S: Serializer,
1835 {
1836 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1837 self.0, serializer,
1838 )
1839 }
1840 }
1841 &SerializeWith(&self.r#content_location)
1842 })?;
1843 } else {
1844 serialize_struct.skip_field("contentLocation")?;
1845 }
1846 if !Vec::is_empty(&self.r#content_rating) {
1847 serialize_struct.serialize_field("contentRating", {
1848 struct SerializeWith<'a>(&'a Vec<ContentRatingProperty>);
1849 impl<'a> Serialize for SerializeWith<'a> {
1850 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1851 where
1852 S: Serializer,
1853 {
1854 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1855 self.0, serializer,
1856 )
1857 }
1858 }
1859 &SerializeWith(&self.r#content_rating)
1860 })?;
1861 } else {
1862 serialize_struct.skip_field("contentRating")?;
1863 }
1864 if !Vec::is_empty(&self.r#content_reference_time) {
1865 serialize_struct.serialize_field("contentReferenceTime", {
1866 struct SerializeWith<'a>(&'a Vec<ContentReferenceTimeProperty>);
1867 impl<'a> Serialize for SerializeWith<'a> {
1868 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1869 where
1870 S: Serializer,
1871 {
1872 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1873 self.0, serializer,
1874 )
1875 }
1876 }
1877 &SerializeWith(&self.r#content_reference_time)
1878 })?;
1879 } else {
1880 serialize_struct.skip_field("contentReferenceTime")?;
1881 }
1882 if !Vec::is_empty(&self.r#contributor) {
1883 serialize_struct.serialize_field("contributor", {
1884 struct SerializeWith<'a>(&'a Vec<ContributorProperty>);
1885 impl<'a> Serialize for SerializeWith<'a> {
1886 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1887 where
1888 S: Serializer,
1889 {
1890 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1891 self.0, serializer,
1892 )
1893 }
1894 }
1895 &SerializeWith(&self.r#contributor)
1896 })?;
1897 } else {
1898 serialize_struct.skip_field("contributor")?;
1899 }
1900 if !Vec::is_empty(&self.r#copyright_holder) {
1901 serialize_struct.serialize_field("copyrightHolder", {
1902 struct SerializeWith<'a>(&'a Vec<CopyrightHolderProperty>);
1903 impl<'a> Serialize for SerializeWith<'a> {
1904 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1905 where
1906 S: Serializer,
1907 {
1908 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1909 self.0, serializer,
1910 )
1911 }
1912 }
1913 &SerializeWith(&self.r#copyright_holder)
1914 })?;
1915 } else {
1916 serialize_struct.skip_field("copyrightHolder")?;
1917 }
1918 if !Vec::is_empty(&self.r#copyright_notice) {
1919 serialize_struct.serialize_field("copyrightNotice", {
1920 struct SerializeWith<'a>(&'a Vec<CopyrightNoticeProperty>);
1921 impl<'a> Serialize for SerializeWith<'a> {
1922 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1923 where
1924 S: Serializer,
1925 {
1926 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1927 self.0, serializer,
1928 )
1929 }
1930 }
1931 &SerializeWith(&self.r#copyright_notice)
1932 })?;
1933 } else {
1934 serialize_struct.skip_field("copyrightNotice")?;
1935 }
1936 if !Vec::is_empty(&self.r#copyright_year) {
1937 serialize_struct.serialize_field("copyrightYear", {
1938 struct SerializeWith<'a>(&'a Vec<CopyrightYearProperty>);
1939 impl<'a> Serialize for SerializeWith<'a> {
1940 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1941 where
1942 S: Serializer,
1943 {
1944 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1945 self.0, serializer,
1946 )
1947 }
1948 }
1949 &SerializeWith(&self.r#copyright_year)
1950 })?;
1951 } else {
1952 serialize_struct.skip_field("copyrightYear")?;
1953 }
1954 if !Vec::is_empty(&self.r#correction) {
1955 serialize_struct.serialize_field("correction", {
1956 struct SerializeWith<'a>(&'a Vec<CorrectionProperty>);
1957 impl<'a> Serialize for SerializeWith<'a> {
1958 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1959 where
1960 S: Serializer,
1961 {
1962 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1963 self.0, serializer,
1964 )
1965 }
1966 }
1967 &SerializeWith(&self.r#correction)
1968 })?;
1969 } else {
1970 serialize_struct.skip_field("correction")?;
1971 }
1972 if !Vec::is_empty(&self.r#creative_work_status) {
1973 serialize_struct.serialize_field("creativeWorkStatus", {
1974 struct SerializeWith<'a>(&'a Vec<CreativeWorkStatusProperty>);
1975 impl<'a> Serialize for SerializeWith<'a> {
1976 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1977 where
1978 S: Serializer,
1979 {
1980 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1981 self.0, serializer,
1982 )
1983 }
1984 }
1985 &SerializeWith(&self.r#creative_work_status)
1986 })?;
1987 } else {
1988 serialize_struct.skip_field("creativeWorkStatus")?;
1989 }
1990 if !Vec::is_empty(&self.r#creator) {
1991 serialize_struct.serialize_field("creator", {
1992 struct SerializeWith<'a>(&'a Vec<CreatorProperty>);
1993 impl<'a> Serialize for SerializeWith<'a> {
1994 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1995 where
1996 S: Serializer,
1997 {
1998 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
1999 self.0, serializer,
2000 )
2001 }
2002 }
2003 &SerializeWith(&self.r#creator)
2004 })?;
2005 } else {
2006 serialize_struct.skip_field("creator")?;
2007 }
2008 if !Vec::is_empty(&self.r#credit_text) {
2009 serialize_struct.serialize_field("creditText", {
2010 struct SerializeWith<'a>(&'a Vec<CreditTextProperty>);
2011 impl<'a> Serialize for SerializeWith<'a> {
2012 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2013 where
2014 S: Serializer,
2015 {
2016 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2017 self.0, serializer,
2018 )
2019 }
2020 }
2021 &SerializeWith(&self.r#credit_text)
2022 })?;
2023 } else {
2024 serialize_struct.skip_field("creditText")?;
2025 }
2026 if !Vec::is_empty(&self.r#date_created) {
2027 serialize_struct.serialize_field("dateCreated", {
2028 struct SerializeWith<'a>(&'a Vec<DateCreatedProperty>);
2029 impl<'a> Serialize for SerializeWith<'a> {
2030 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2031 where
2032 S: Serializer,
2033 {
2034 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2035 self.0, serializer,
2036 )
2037 }
2038 }
2039 &SerializeWith(&self.r#date_created)
2040 })?;
2041 } else {
2042 serialize_struct.skip_field("dateCreated")?;
2043 }
2044 if !Vec::is_empty(&self.r#date_modified) {
2045 serialize_struct.serialize_field("dateModified", {
2046 struct SerializeWith<'a>(&'a Vec<DateModifiedProperty>);
2047 impl<'a> Serialize for SerializeWith<'a> {
2048 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2049 where
2050 S: Serializer,
2051 {
2052 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2053 self.0, serializer,
2054 )
2055 }
2056 }
2057 &SerializeWith(&self.r#date_modified)
2058 })?;
2059 } else {
2060 serialize_struct.skip_field("dateModified")?;
2061 }
2062 if !Vec::is_empty(&self.r#date_published) {
2063 serialize_struct.serialize_field("datePublished", {
2064 struct SerializeWith<'a>(&'a Vec<DatePublishedProperty>);
2065 impl<'a> Serialize for SerializeWith<'a> {
2066 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2067 where
2068 S: Serializer,
2069 {
2070 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2071 self.0, serializer,
2072 )
2073 }
2074 }
2075 &SerializeWith(&self.r#date_published)
2076 })?;
2077 } else {
2078 serialize_struct.skip_field("datePublished")?;
2079 }
2080 if !Vec::is_empty(&self.r#discussion_url) {
2081 serialize_struct.serialize_field("discussionUrl", {
2082 struct SerializeWith<'a>(&'a Vec<DiscussionUrlProperty>);
2083 impl<'a> Serialize for SerializeWith<'a> {
2084 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2085 where
2086 S: Serializer,
2087 {
2088 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2089 self.0, serializer,
2090 )
2091 }
2092 }
2093 &SerializeWith(&self.r#discussion_url)
2094 })?;
2095 } else {
2096 serialize_struct.skip_field("discussionUrl")?;
2097 }
2098 if !Vec::is_empty(&self.r#edit_eidr) {
2099 serialize_struct.serialize_field("editEIDR", {
2100 struct SerializeWith<'a>(&'a Vec<EditEidrProperty>);
2101 impl<'a> Serialize for SerializeWith<'a> {
2102 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2103 where
2104 S: Serializer,
2105 {
2106 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2107 self.0, serializer,
2108 )
2109 }
2110 }
2111 &SerializeWith(&self.r#edit_eidr)
2112 })?;
2113 } else {
2114 serialize_struct.skip_field("editEIDR")?;
2115 }
2116 if !Vec::is_empty(&self.r#editor) {
2117 serialize_struct.serialize_field("editor", {
2118 struct SerializeWith<'a>(&'a Vec<EditorProperty>);
2119 impl<'a> Serialize for SerializeWith<'a> {
2120 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2121 where
2122 S: Serializer,
2123 {
2124 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2125 self.0, serializer,
2126 )
2127 }
2128 }
2129 &SerializeWith(&self.r#editor)
2130 })?;
2131 } else {
2132 serialize_struct.skip_field("editor")?;
2133 }
2134 if !Vec::is_empty(&self.r#educational_alignment) {
2135 serialize_struct.serialize_field("educationalAlignment", {
2136 struct SerializeWith<'a>(&'a Vec<EducationalAlignmentProperty>);
2137 impl<'a> Serialize for SerializeWith<'a> {
2138 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2139 where
2140 S: Serializer,
2141 {
2142 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2143 self.0, serializer,
2144 )
2145 }
2146 }
2147 &SerializeWith(&self.r#educational_alignment)
2148 })?;
2149 } else {
2150 serialize_struct.skip_field("educationalAlignment")?;
2151 }
2152 if !Vec::is_empty(&self.r#educational_level) {
2153 serialize_struct.serialize_field("educationalLevel", {
2154 struct SerializeWith<'a>(&'a Vec<EducationalLevelProperty>);
2155 impl<'a> Serialize for SerializeWith<'a> {
2156 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2157 where
2158 S: Serializer,
2159 {
2160 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2161 self.0, serializer,
2162 )
2163 }
2164 }
2165 &SerializeWith(&self.r#educational_level)
2166 })?;
2167 } else {
2168 serialize_struct.skip_field("educationalLevel")?;
2169 }
2170 if !Vec::is_empty(&self.r#educational_use) {
2171 serialize_struct.serialize_field("educationalUse", {
2172 struct SerializeWith<'a>(&'a Vec<EducationalUseProperty>);
2173 impl<'a> Serialize for SerializeWith<'a> {
2174 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2175 where
2176 S: Serializer,
2177 {
2178 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2179 self.0, serializer,
2180 )
2181 }
2182 }
2183 &SerializeWith(&self.r#educational_use)
2184 })?;
2185 } else {
2186 serialize_struct.skip_field("educationalUse")?;
2187 }
2188 if !Vec::is_empty(&self.r#encoding) {
2189 serialize_struct.serialize_field("encoding", {
2190 struct SerializeWith<'a>(&'a Vec<EncodingProperty>);
2191 impl<'a> Serialize for SerializeWith<'a> {
2192 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2193 where
2194 S: Serializer,
2195 {
2196 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2197 self.0, serializer,
2198 )
2199 }
2200 }
2201 &SerializeWith(&self.r#encoding)
2202 })?;
2203 } else {
2204 serialize_struct.skip_field("encoding")?;
2205 }
2206 if !Vec::is_empty(&self.r#encoding_format) {
2207 serialize_struct.serialize_field("encodingFormat", {
2208 struct SerializeWith<'a>(&'a Vec<EncodingFormatProperty>);
2209 impl<'a> Serialize for SerializeWith<'a> {
2210 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2211 where
2212 S: Serializer,
2213 {
2214 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2215 self.0, serializer,
2216 )
2217 }
2218 }
2219 &SerializeWith(&self.r#encoding_format)
2220 })?;
2221 } else {
2222 serialize_struct.skip_field("encodingFormat")?;
2223 }
2224 if !Vec::is_empty(&self.r#encodings) {
2225 serialize_struct.serialize_field("encodings", {
2226 struct SerializeWith<'a>(&'a Vec<EncodingsProperty>);
2227 impl<'a> Serialize for SerializeWith<'a> {
2228 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2229 where
2230 S: Serializer,
2231 {
2232 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2233 self.0, serializer,
2234 )
2235 }
2236 }
2237 &SerializeWith(&self.r#encodings)
2238 })?;
2239 } else {
2240 serialize_struct.skip_field("encodings")?;
2241 }
2242 if !Vec::is_empty(&self.r#example_of_work) {
2243 serialize_struct.serialize_field("exampleOfWork", {
2244 struct SerializeWith<'a>(&'a Vec<ExampleOfWorkProperty>);
2245 impl<'a> Serialize for SerializeWith<'a> {
2246 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2247 where
2248 S: Serializer,
2249 {
2250 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2251 self.0, serializer,
2252 )
2253 }
2254 }
2255 &SerializeWith(&self.r#example_of_work)
2256 })?;
2257 } else {
2258 serialize_struct.skip_field("exampleOfWork")?;
2259 }
2260 if !Vec::is_empty(&self.r#expires) {
2261 serialize_struct.serialize_field("expires", {
2262 struct SerializeWith<'a>(&'a Vec<ExpiresProperty>);
2263 impl<'a> Serialize for SerializeWith<'a> {
2264 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2265 where
2266 S: Serializer,
2267 {
2268 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2269 self.0, serializer,
2270 )
2271 }
2272 }
2273 &SerializeWith(&self.r#expires)
2274 })?;
2275 } else {
2276 serialize_struct.skip_field("expires")?;
2277 }
2278 if !Vec::is_empty(&self.r#file_format) {
2279 serialize_struct.serialize_field("fileFormat", {
2280 struct SerializeWith<'a>(&'a Vec<FileFormatProperty>);
2281 impl<'a> Serialize for SerializeWith<'a> {
2282 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2283 where
2284 S: Serializer,
2285 {
2286 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2287 self.0, serializer,
2288 )
2289 }
2290 }
2291 &SerializeWith(&self.r#file_format)
2292 })?;
2293 } else {
2294 serialize_struct.skip_field("fileFormat")?;
2295 }
2296 if !Vec::is_empty(&self.r#funder) {
2297 serialize_struct.serialize_field("funder", {
2298 struct SerializeWith<'a>(&'a Vec<FunderProperty>);
2299 impl<'a> Serialize for SerializeWith<'a> {
2300 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2301 where
2302 S: Serializer,
2303 {
2304 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2305 self.0, serializer,
2306 )
2307 }
2308 }
2309 &SerializeWith(&self.r#funder)
2310 })?;
2311 } else {
2312 serialize_struct.skip_field("funder")?;
2313 }
2314 if !Vec::is_empty(&self.r#funding) {
2315 serialize_struct.serialize_field("funding", {
2316 struct SerializeWith<'a>(&'a Vec<FundingProperty>);
2317 impl<'a> Serialize for SerializeWith<'a> {
2318 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2319 where
2320 S: Serializer,
2321 {
2322 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2323 self.0, serializer,
2324 )
2325 }
2326 }
2327 &SerializeWith(&self.r#funding)
2328 })?;
2329 } else {
2330 serialize_struct.skip_field("funding")?;
2331 }
2332 if !Vec::is_empty(&self.r#genre) {
2333 serialize_struct.serialize_field("genre", {
2334 struct SerializeWith<'a>(&'a Vec<GenreProperty>);
2335 impl<'a> Serialize for SerializeWith<'a> {
2336 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2337 where
2338 S: Serializer,
2339 {
2340 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2341 self.0, serializer,
2342 )
2343 }
2344 }
2345 &SerializeWith(&self.r#genre)
2346 })?;
2347 } else {
2348 serialize_struct.skip_field("genre")?;
2349 }
2350 if !Vec::is_empty(&self.r#has_part) {
2351 serialize_struct.serialize_field("hasPart", {
2352 struct SerializeWith<'a>(&'a Vec<HasPartProperty>);
2353 impl<'a> Serialize for SerializeWith<'a> {
2354 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2355 where
2356 S: Serializer,
2357 {
2358 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2359 self.0, serializer,
2360 )
2361 }
2362 }
2363 &SerializeWith(&self.r#has_part)
2364 })?;
2365 } else {
2366 serialize_struct.skip_field("hasPart")?;
2367 }
2368 if !Vec::is_empty(&self.r#headline) {
2369 serialize_struct.serialize_field("headline", {
2370 struct SerializeWith<'a>(&'a Vec<HeadlineProperty>);
2371 impl<'a> Serialize for SerializeWith<'a> {
2372 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2373 where
2374 S: Serializer,
2375 {
2376 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2377 self.0, serializer,
2378 )
2379 }
2380 }
2381 &SerializeWith(&self.r#headline)
2382 })?;
2383 } else {
2384 serialize_struct.skip_field("headline")?;
2385 }
2386 if !Vec::is_empty(&self.r#in_language) {
2387 serialize_struct.serialize_field("inLanguage", {
2388 struct SerializeWith<'a>(&'a Vec<InLanguageProperty>);
2389 impl<'a> Serialize for SerializeWith<'a> {
2390 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2391 where
2392 S: Serializer,
2393 {
2394 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2395 self.0, serializer,
2396 )
2397 }
2398 }
2399 &SerializeWith(&self.r#in_language)
2400 })?;
2401 } else {
2402 serialize_struct.skip_field("inLanguage")?;
2403 }
2404 if !Vec::is_empty(&self.r#interaction_statistic) {
2405 serialize_struct.serialize_field("interactionStatistic", {
2406 struct SerializeWith<'a>(&'a Vec<InteractionStatisticProperty>);
2407 impl<'a> Serialize for SerializeWith<'a> {
2408 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2409 where
2410 S: Serializer,
2411 {
2412 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2413 self.0, serializer,
2414 )
2415 }
2416 }
2417 &SerializeWith(&self.r#interaction_statistic)
2418 })?;
2419 } else {
2420 serialize_struct.skip_field("interactionStatistic")?;
2421 }
2422 if !Vec::is_empty(&self.r#interactivity_type) {
2423 serialize_struct.serialize_field("interactivityType", {
2424 struct SerializeWith<'a>(&'a Vec<InteractivityTypeProperty>);
2425 impl<'a> Serialize for SerializeWith<'a> {
2426 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2427 where
2428 S: Serializer,
2429 {
2430 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2431 self.0, serializer,
2432 )
2433 }
2434 }
2435 &SerializeWith(&self.r#interactivity_type)
2436 })?;
2437 } else {
2438 serialize_struct.skip_field("interactivityType")?;
2439 }
2440 if !Vec::is_empty(&self.r#interpreted_as_claim) {
2441 serialize_struct.serialize_field("interpretedAsClaim", {
2442 struct SerializeWith<'a>(&'a Vec<InterpretedAsClaimProperty>);
2443 impl<'a> Serialize for SerializeWith<'a> {
2444 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2445 where
2446 S: Serializer,
2447 {
2448 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2449 self.0, serializer,
2450 )
2451 }
2452 }
2453 &SerializeWith(&self.r#interpreted_as_claim)
2454 })?;
2455 } else {
2456 serialize_struct.skip_field("interpretedAsClaim")?;
2457 }
2458 if !Vec::is_empty(&self.r#is_accessible_for_free) {
2459 serialize_struct.serialize_field("isAccessibleForFree", {
2460 struct SerializeWith<'a>(&'a Vec<IsAccessibleForFreeProperty>);
2461 impl<'a> Serialize for SerializeWith<'a> {
2462 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2463 where
2464 S: Serializer,
2465 {
2466 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2467 self.0, serializer,
2468 )
2469 }
2470 }
2471 &SerializeWith(&self.r#is_accessible_for_free)
2472 })?;
2473 } else {
2474 serialize_struct.skip_field("isAccessibleForFree")?;
2475 }
2476 if !Vec::is_empty(&self.r#is_based_on) {
2477 serialize_struct.serialize_field("isBasedOn", {
2478 struct SerializeWith<'a>(&'a Vec<IsBasedOnProperty>);
2479 impl<'a> Serialize for SerializeWith<'a> {
2480 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2481 where
2482 S: Serializer,
2483 {
2484 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2485 self.0, serializer,
2486 )
2487 }
2488 }
2489 &SerializeWith(&self.r#is_based_on)
2490 })?;
2491 } else {
2492 serialize_struct.skip_field("isBasedOn")?;
2493 }
2494 if !Vec::is_empty(&self.r#is_based_on_url) {
2495 serialize_struct.serialize_field("isBasedOnUrl", {
2496 struct SerializeWith<'a>(&'a Vec<IsBasedOnUrlProperty>);
2497 impl<'a> Serialize for SerializeWith<'a> {
2498 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2499 where
2500 S: Serializer,
2501 {
2502 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2503 self.0, serializer,
2504 )
2505 }
2506 }
2507 &SerializeWith(&self.r#is_based_on_url)
2508 })?;
2509 } else {
2510 serialize_struct.skip_field("isBasedOnUrl")?;
2511 }
2512 if !Vec::is_empty(&self.r#is_family_friendly) {
2513 serialize_struct.serialize_field("isFamilyFriendly", {
2514 struct SerializeWith<'a>(&'a Vec<IsFamilyFriendlyProperty>);
2515 impl<'a> Serialize for SerializeWith<'a> {
2516 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2517 where
2518 S: Serializer,
2519 {
2520 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2521 self.0, serializer,
2522 )
2523 }
2524 }
2525 &SerializeWith(&self.r#is_family_friendly)
2526 })?;
2527 } else {
2528 serialize_struct.skip_field("isFamilyFriendly")?;
2529 }
2530 if !Vec::is_empty(&self.r#is_part_of) {
2531 serialize_struct.serialize_field("isPartOf", {
2532 struct SerializeWith<'a>(&'a Vec<IsPartOfProperty>);
2533 impl<'a> Serialize for SerializeWith<'a> {
2534 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2535 where
2536 S: Serializer,
2537 {
2538 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2539 self.0, serializer,
2540 )
2541 }
2542 }
2543 &SerializeWith(&self.r#is_part_of)
2544 })?;
2545 } else {
2546 serialize_struct.skip_field("isPartOf")?;
2547 }
2548 if !Vec::is_empty(&self.r#keywords) {
2549 serialize_struct.serialize_field("keywords", {
2550 struct SerializeWith<'a>(&'a Vec<KeywordsProperty>);
2551 impl<'a> Serialize for SerializeWith<'a> {
2552 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2553 where
2554 S: Serializer,
2555 {
2556 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2557 self.0, serializer,
2558 )
2559 }
2560 }
2561 &SerializeWith(&self.r#keywords)
2562 })?;
2563 } else {
2564 serialize_struct.skip_field("keywords")?;
2565 }
2566 if !Vec::is_empty(&self.r#learning_resource_type) {
2567 serialize_struct.serialize_field("learningResourceType", {
2568 struct SerializeWith<'a>(&'a Vec<LearningResourceTypeProperty>);
2569 impl<'a> Serialize for SerializeWith<'a> {
2570 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2571 where
2572 S: Serializer,
2573 {
2574 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2575 self.0, serializer,
2576 )
2577 }
2578 }
2579 &SerializeWith(&self.r#learning_resource_type)
2580 })?;
2581 } else {
2582 serialize_struct.skip_field("learningResourceType")?;
2583 }
2584 if !Vec::is_empty(&self.r#license) {
2585 serialize_struct.serialize_field("license", {
2586 struct SerializeWith<'a>(&'a Vec<LicenseProperty>);
2587 impl<'a> Serialize for SerializeWith<'a> {
2588 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2589 where
2590 S: Serializer,
2591 {
2592 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2593 self.0, serializer,
2594 )
2595 }
2596 }
2597 &SerializeWith(&self.r#license)
2598 })?;
2599 } else {
2600 serialize_struct.skip_field("license")?;
2601 }
2602 if !Vec::is_empty(&self.r#location_created) {
2603 serialize_struct.serialize_field("locationCreated", {
2604 struct SerializeWith<'a>(&'a Vec<LocationCreatedProperty>);
2605 impl<'a> Serialize for SerializeWith<'a> {
2606 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2607 where
2608 S: Serializer,
2609 {
2610 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2611 self.0, serializer,
2612 )
2613 }
2614 }
2615 &SerializeWith(&self.r#location_created)
2616 })?;
2617 } else {
2618 serialize_struct.skip_field("locationCreated")?;
2619 }
2620 if !Vec::is_empty(&self.r#main_entity) {
2621 serialize_struct.serialize_field("mainEntity", {
2622 struct SerializeWith<'a>(&'a Vec<MainEntityProperty>);
2623 impl<'a> Serialize for SerializeWith<'a> {
2624 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2625 where
2626 S: Serializer,
2627 {
2628 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2629 self.0, serializer,
2630 )
2631 }
2632 }
2633 &SerializeWith(&self.r#main_entity)
2634 })?;
2635 } else {
2636 serialize_struct.skip_field("mainEntity")?;
2637 }
2638 if !Vec::is_empty(&self.r#maintainer) {
2639 serialize_struct.serialize_field("maintainer", {
2640 struct SerializeWith<'a>(&'a Vec<MaintainerProperty>);
2641 impl<'a> Serialize for SerializeWith<'a> {
2642 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2643 where
2644 S: Serializer,
2645 {
2646 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2647 self.0, serializer,
2648 )
2649 }
2650 }
2651 &SerializeWith(&self.r#maintainer)
2652 })?;
2653 } else {
2654 serialize_struct.skip_field("maintainer")?;
2655 }
2656 if !Vec::is_empty(&self.r#material) {
2657 serialize_struct.serialize_field("material", {
2658 struct SerializeWith<'a>(&'a Vec<MaterialProperty>);
2659 impl<'a> Serialize for SerializeWith<'a> {
2660 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2661 where
2662 S: Serializer,
2663 {
2664 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2665 self.0, serializer,
2666 )
2667 }
2668 }
2669 &SerializeWith(&self.r#material)
2670 })?;
2671 } else {
2672 serialize_struct.skip_field("material")?;
2673 }
2674 if !Vec::is_empty(&self.r#material_extent) {
2675 serialize_struct.serialize_field("materialExtent", {
2676 struct SerializeWith<'a>(&'a Vec<MaterialExtentProperty>);
2677 impl<'a> Serialize for SerializeWith<'a> {
2678 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2679 where
2680 S: Serializer,
2681 {
2682 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2683 self.0, serializer,
2684 )
2685 }
2686 }
2687 &SerializeWith(&self.r#material_extent)
2688 })?;
2689 } else {
2690 serialize_struct.skip_field("materialExtent")?;
2691 }
2692 if !Vec::is_empty(&self.r#mentions) {
2693 serialize_struct.serialize_field("mentions", {
2694 struct SerializeWith<'a>(&'a Vec<MentionsProperty>);
2695 impl<'a> Serialize for SerializeWith<'a> {
2696 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2697 where
2698 S: Serializer,
2699 {
2700 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2701 self.0, serializer,
2702 )
2703 }
2704 }
2705 &SerializeWith(&self.r#mentions)
2706 })?;
2707 } else {
2708 serialize_struct.skip_field("mentions")?;
2709 }
2710 if !Vec::is_empty(&self.r#offers) {
2711 serialize_struct.serialize_field("offers", {
2712 struct SerializeWith<'a>(&'a Vec<OffersProperty>);
2713 impl<'a> Serialize for SerializeWith<'a> {
2714 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2715 where
2716 S: Serializer,
2717 {
2718 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2719 self.0, serializer,
2720 )
2721 }
2722 }
2723 &SerializeWith(&self.r#offers)
2724 })?;
2725 } else {
2726 serialize_struct.skip_field("offers")?;
2727 }
2728 if !Vec::is_empty(&self.r#pattern) {
2729 serialize_struct.serialize_field("pattern", {
2730 struct SerializeWith<'a>(&'a Vec<PatternProperty>);
2731 impl<'a> Serialize for SerializeWith<'a> {
2732 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2733 where
2734 S: Serializer,
2735 {
2736 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2737 self.0, serializer,
2738 )
2739 }
2740 }
2741 &SerializeWith(&self.r#pattern)
2742 })?;
2743 } else {
2744 serialize_struct.skip_field("pattern")?;
2745 }
2746 if !Vec::is_empty(&self.r#position) {
2747 serialize_struct.serialize_field("position", {
2748 struct SerializeWith<'a>(&'a Vec<PositionProperty>);
2749 impl<'a> Serialize for SerializeWith<'a> {
2750 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2751 where
2752 S: Serializer,
2753 {
2754 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2755 self.0, serializer,
2756 )
2757 }
2758 }
2759 &SerializeWith(&self.r#position)
2760 })?;
2761 } else {
2762 serialize_struct.skip_field("position")?;
2763 }
2764 if !Vec::is_empty(&self.r#producer) {
2765 serialize_struct.serialize_field("producer", {
2766 struct SerializeWith<'a>(&'a Vec<ProducerProperty>);
2767 impl<'a> Serialize for SerializeWith<'a> {
2768 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2769 where
2770 S: Serializer,
2771 {
2772 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2773 self.0, serializer,
2774 )
2775 }
2776 }
2777 &SerializeWith(&self.r#producer)
2778 })?;
2779 } else {
2780 serialize_struct.skip_field("producer")?;
2781 }
2782 if !Vec::is_empty(&self.r#provider) {
2783 serialize_struct.serialize_field("provider", {
2784 struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
2785 impl<'a> Serialize for SerializeWith<'a> {
2786 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2787 where
2788 S: Serializer,
2789 {
2790 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2791 self.0, serializer,
2792 )
2793 }
2794 }
2795 &SerializeWith(&self.r#provider)
2796 })?;
2797 } else {
2798 serialize_struct.skip_field("provider")?;
2799 }
2800 if !Vec::is_empty(&self.r#publication) {
2801 serialize_struct.serialize_field("publication", {
2802 struct SerializeWith<'a>(&'a Vec<PublicationProperty>);
2803 impl<'a> Serialize for SerializeWith<'a> {
2804 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2805 where
2806 S: Serializer,
2807 {
2808 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2809 self.0, serializer,
2810 )
2811 }
2812 }
2813 &SerializeWith(&self.r#publication)
2814 })?;
2815 } else {
2816 serialize_struct.skip_field("publication")?;
2817 }
2818 if !Vec::is_empty(&self.r#publisher) {
2819 serialize_struct.serialize_field("publisher", {
2820 struct SerializeWith<'a>(&'a Vec<PublisherProperty>);
2821 impl<'a> Serialize for SerializeWith<'a> {
2822 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2823 where
2824 S: Serializer,
2825 {
2826 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2827 self.0, serializer,
2828 )
2829 }
2830 }
2831 &SerializeWith(&self.r#publisher)
2832 })?;
2833 } else {
2834 serialize_struct.skip_field("publisher")?;
2835 }
2836 if !Vec::is_empty(&self.r#publisher_imprint) {
2837 serialize_struct.serialize_field("publisherImprint", {
2838 struct SerializeWith<'a>(&'a Vec<PublisherImprintProperty>);
2839 impl<'a> Serialize for SerializeWith<'a> {
2840 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2841 where
2842 S: Serializer,
2843 {
2844 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2845 self.0, serializer,
2846 )
2847 }
2848 }
2849 &SerializeWith(&self.r#publisher_imprint)
2850 })?;
2851 } else {
2852 serialize_struct.skip_field("publisherImprint")?;
2853 }
2854 if !Vec::is_empty(&self.r#publishing_principles) {
2855 serialize_struct.serialize_field("publishingPrinciples", {
2856 struct SerializeWith<'a>(&'a Vec<PublishingPrinciplesProperty>);
2857 impl<'a> Serialize for SerializeWith<'a> {
2858 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2859 where
2860 S: Serializer,
2861 {
2862 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2863 self.0, serializer,
2864 )
2865 }
2866 }
2867 &SerializeWith(&self.r#publishing_principles)
2868 })?;
2869 } else {
2870 serialize_struct.skip_field("publishingPrinciples")?;
2871 }
2872 if !Vec::is_empty(&self.r#recorded_at) {
2873 serialize_struct.serialize_field("recordedAt", {
2874 struct SerializeWith<'a>(&'a Vec<RecordedAtProperty>);
2875 impl<'a> Serialize for SerializeWith<'a> {
2876 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2877 where
2878 S: Serializer,
2879 {
2880 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2881 self.0, serializer,
2882 )
2883 }
2884 }
2885 &SerializeWith(&self.r#recorded_at)
2886 })?;
2887 } else {
2888 serialize_struct.skip_field("recordedAt")?;
2889 }
2890 if !Vec::is_empty(&self.r#released_event) {
2891 serialize_struct.serialize_field("releasedEvent", {
2892 struct SerializeWith<'a>(&'a Vec<ReleasedEventProperty>);
2893 impl<'a> Serialize for SerializeWith<'a> {
2894 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2895 where
2896 S: Serializer,
2897 {
2898 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2899 self.0, serializer,
2900 )
2901 }
2902 }
2903 &SerializeWith(&self.r#released_event)
2904 })?;
2905 } else {
2906 serialize_struct.skip_field("releasedEvent")?;
2907 }
2908 if !Vec::is_empty(&self.r#review) {
2909 serialize_struct.serialize_field("review", {
2910 struct SerializeWith<'a>(&'a Vec<ReviewProperty>);
2911 impl<'a> Serialize for SerializeWith<'a> {
2912 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2913 where
2914 S: Serializer,
2915 {
2916 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2917 self.0, serializer,
2918 )
2919 }
2920 }
2921 &SerializeWith(&self.r#review)
2922 })?;
2923 } else {
2924 serialize_struct.skip_field("review")?;
2925 }
2926 if !Vec::is_empty(&self.r#reviews) {
2927 serialize_struct.serialize_field("reviews", {
2928 struct SerializeWith<'a>(&'a Vec<ReviewsProperty>);
2929 impl<'a> Serialize for SerializeWith<'a> {
2930 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2931 where
2932 S: Serializer,
2933 {
2934 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2935 self.0, serializer,
2936 )
2937 }
2938 }
2939 &SerializeWith(&self.r#reviews)
2940 })?;
2941 } else {
2942 serialize_struct.skip_field("reviews")?;
2943 }
2944 if !Vec::is_empty(&self.r#schema_version) {
2945 serialize_struct.serialize_field("schemaVersion", {
2946 struct SerializeWith<'a>(&'a Vec<SchemaVersionProperty>);
2947 impl<'a> Serialize for SerializeWith<'a> {
2948 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2949 where
2950 S: Serializer,
2951 {
2952 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2953 self.0, serializer,
2954 )
2955 }
2956 }
2957 &SerializeWith(&self.r#schema_version)
2958 })?;
2959 } else {
2960 serialize_struct.skip_field("schemaVersion")?;
2961 }
2962 if !Vec::is_empty(&self.r#sd_date_published) {
2963 serialize_struct.serialize_field("sdDatePublished", {
2964 struct SerializeWith<'a>(&'a Vec<SdDatePublishedProperty>);
2965 impl<'a> Serialize for SerializeWith<'a> {
2966 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2967 where
2968 S: Serializer,
2969 {
2970 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2971 self.0, serializer,
2972 )
2973 }
2974 }
2975 &SerializeWith(&self.r#sd_date_published)
2976 })?;
2977 } else {
2978 serialize_struct.skip_field("sdDatePublished")?;
2979 }
2980 if !Vec::is_empty(&self.r#sd_license) {
2981 serialize_struct.serialize_field("sdLicense", {
2982 struct SerializeWith<'a>(&'a Vec<SdLicenseProperty>);
2983 impl<'a> Serialize for SerializeWith<'a> {
2984 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2985 where
2986 S: Serializer,
2987 {
2988 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
2989 self.0, serializer,
2990 )
2991 }
2992 }
2993 &SerializeWith(&self.r#sd_license)
2994 })?;
2995 } else {
2996 serialize_struct.skip_field("sdLicense")?;
2997 }
2998 if !Vec::is_empty(&self.r#sd_publisher) {
2999 serialize_struct.serialize_field("sdPublisher", {
3000 struct SerializeWith<'a>(&'a Vec<SdPublisherProperty>);
3001 impl<'a> Serialize for SerializeWith<'a> {
3002 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3003 where
3004 S: Serializer,
3005 {
3006 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3007 self.0, serializer,
3008 )
3009 }
3010 }
3011 &SerializeWith(&self.r#sd_publisher)
3012 })?;
3013 } else {
3014 serialize_struct.skip_field("sdPublisher")?;
3015 }
3016 if !Vec::is_empty(&self.r#size) {
3017 serialize_struct.serialize_field("size", {
3018 struct SerializeWith<'a>(&'a Vec<SizeProperty>);
3019 impl<'a> Serialize for SerializeWith<'a> {
3020 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3021 where
3022 S: Serializer,
3023 {
3024 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3025 self.0, serializer,
3026 )
3027 }
3028 }
3029 &SerializeWith(&self.r#size)
3030 })?;
3031 } else {
3032 serialize_struct.skip_field("size")?;
3033 }
3034 if !Vec::is_empty(&self.r#source_organization) {
3035 serialize_struct.serialize_field("sourceOrganization", {
3036 struct SerializeWith<'a>(&'a Vec<SourceOrganizationProperty>);
3037 impl<'a> Serialize for SerializeWith<'a> {
3038 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3039 where
3040 S: Serializer,
3041 {
3042 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3043 self.0, serializer,
3044 )
3045 }
3046 }
3047 &SerializeWith(&self.r#source_organization)
3048 })?;
3049 } else {
3050 serialize_struct.skip_field("sourceOrganization")?;
3051 }
3052 if !Vec::is_empty(&self.r#spatial) {
3053 serialize_struct.serialize_field("spatial", {
3054 struct SerializeWith<'a>(&'a Vec<SpatialProperty>);
3055 impl<'a> Serialize for SerializeWith<'a> {
3056 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3057 where
3058 S: Serializer,
3059 {
3060 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3061 self.0, serializer,
3062 )
3063 }
3064 }
3065 &SerializeWith(&self.r#spatial)
3066 })?;
3067 } else {
3068 serialize_struct.skip_field("spatial")?;
3069 }
3070 if !Vec::is_empty(&self.r#spatial_coverage) {
3071 serialize_struct.serialize_field("spatialCoverage", {
3072 struct SerializeWith<'a>(&'a Vec<SpatialCoverageProperty>);
3073 impl<'a> Serialize for SerializeWith<'a> {
3074 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3075 where
3076 S: Serializer,
3077 {
3078 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3079 self.0, serializer,
3080 )
3081 }
3082 }
3083 &SerializeWith(&self.r#spatial_coverage)
3084 })?;
3085 } else {
3086 serialize_struct.skip_field("spatialCoverage")?;
3087 }
3088 if !Vec::is_empty(&self.r#sponsor) {
3089 serialize_struct.serialize_field("sponsor", {
3090 struct SerializeWith<'a>(&'a Vec<SponsorProperty>);
3091 impl<'a> Serialize for SerializeWith<'a> {
3092 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3093 where
3094 S: Serializer,
3095 {
3096 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3097 self.0, serializer,
3098 )
3099 }
3100 }
3101 &SerializeWith(&self.r#sponsor)
3102 })?;
3103 } else {
3104 serialize_struct.skip_field("sponsor")?;
3105 }
3106 if !Vec::is_empty(&self.r#teaches) {
3107 serialize_struct.serialize_field("teaches", {
3108 struct SerializeWith<'a>(&'a Vec<TeachesProperty>);
3109 impl<'a> Serialize for SerializeWith<'a> {
3110 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3111 where
3112 S: Serializer,
3113 {
3114 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3115 self.0, serializer,
3116 )
3117 }
3118 }
3119 &SerializeWith(&self.r#teaches)
3120 })?;
3121 } else {
3122 serialize_struct.skip_field("teaches")?;
3123 }
3124 if !Vec::is_empty(&self.r#temporal) {
3125 serialize_struct.serialize_field("temporal", {
3126 struct SerializeWith<'a>(&'a Vec<TemporalProperty>);
3127 impl<'a> Serialize for SerializeWith<'a> {
3128 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3129 where
3130 S: Serializer,
3131 {
3132 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3133 self.0, serializer,
3134 )
3135 }
3136 }
3137 &SerializeWith(&self.r#temporal)
3138 })?;
3139 } else {
3140 serialize_struct.skip_field("temporal")?;
3141 }
3142 if !Vec::is_empty(&self.r#temporal_coverage) {
3143 serialize_struct.serialize_field("temporalCoverage", {
3144 struct SerializeWith<'a>(&'a Vec<TemporalCoverageProperty>);
3145 impl<'a> Serialize for SerializeWith<'a> {
3146 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3147 where
3148 S: Serializer,
3149 {
3150 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3151 self.0, serializer,
3152 )
3153 }
3154 }
3155 &SerializeWith(&self.r#temporal_coverage)
3156 })?;
3157 } else {
3158 serialize_struct.skip_field("temporalCoverage")?;
3159 }
3160 if !Vec::is_empty(&self.r#text) {
3161 serialize_struct.serialize_field("text", {
3162 struct SerializeWith<'a>(&'a Vec<TextProperty>);
3163 impl<'a> Serialize for SerializeWith<'a> {
3164 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3165 where
3166 S: Serializer,
3167 {
3168 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3169 self.0, serializer,
3170 )
3171 }
3172 }
3173 &SerializeWith(&self.r#text)
3174 })?;
3175 } else {
3176 serialize_struct.skip_field("text")?;
3177 }
3178 if !Vec::is_empty(&self.r#thumbnail) {
3179 serialize_struct.serialize_field("thumbnail", {
3180 struct SerializeWith<'a>(&'a Vec<ThumbnailProperty>);
3181 impl<'a> Serialize for SerializeWith<'a> {
3182 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3183 where
3184 S: Serializer,
3185 {
3186 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3187 self.0, serializer,
3188 )
3189 }
3190 }
3191 &SerializeWith(&self.r#thumbnail)
3192 })?;
3193 } else {
3194 serialize_struct.skip_field("thumbnail")?;
3195 }
3196 if !Vec::is_empty(&self.r#thumbnail_url) {
3197 serialize_struct.serialize_field("thumbnailUrl", {
3198 struct SerializeWith<'a>(&'a Vec<ThumbnailUrlProperty>);
3199 impl<'a> Serialize for SerializeWith<'a> {
3200 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3201 where
3202 S: Serializer,
3203 {
3204 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3205 self.0, serializer,
3206 )
3207 }
3208 }
3209 &SerializeWith(&self.r#thumbnail_url)
3210 })?;
3211 } else {
3212 serialize_struct.skip_field("thumbnailUrl")?;
3213 }
3214 if !Vec::is_empty(&self.r#time_required) {
3215 serialize_struct.serialize_field("timeRequired", {
3216 struct SerializeWith<'a>(&'a Vec<TimeRequiredProperty>);
3217 impl<'a> Serialize for SerializeWith<'a> {
3218 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3219 where
3220 S: Serializer,
3221 {
3222 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3223 self.0, serializer,
3224 )
3225 }
3226 }
3227 &SerializeWith(&self.r#time_required)
3228 })?;
3229 } else {
3230 serialize_struct.skip_field("timeRequired")?;
3231 }
3232 if !Vec::is_empty(&self.r#translation_of_work) {
3233 serialize_struct.serialize_field("translationOfWork", {
3234 struct SerializeWith<'a>(&'a Vec<TranslationOfWorkProperty>);
3235 impl<'a> Serialize for SerializeWith<'a> {
3236 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3237 where
3238 S: Serializer,
3239 {
3240 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3241 self.0, serializer,
3242 )
3243 }
3244 }
3245 &SerializeWith(&self.r#translation_of_work)
3246 })?;
3247 } else {
3248 serialize_struct.skip_field("translationOfWork")?;
3249 }
3250 if !Vec::is_empty(&self.r#translator) {
3251 serialize_struct.serialize_field("translator", {
3252 struct SerializeWith<'a>(&'a Vec<TranslatorProperty>);
3253 impl<'a> Serialize for SerializeWith<'a> {
3254 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3255 where
3256 S: Serializer,
3257 {
3258 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3259 self.0, serializer,
3260 )
3261 }
3262 }
3263 &SerializeWith(&self.r#translator)
3264 })?;
3265 } else {
3266 serialize_struct.skip_field("translator")?;
3267 }
3268 if !Vec::is_empty(&self.r#typical_age_range) {
3269 serialize_struct.serialize_field("typicalAgeRange", {
3270 struct SerializeWith<'a>(&'a Vec<TypicalAgeRangeProperty>);
3271 impl<'a> Serialize for SerializeWith<'a> {
3272 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3273 where
3274 S: Serializer,
3275 {
3276 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3277 self.0, serializer,
3278 )
3279 }
3280 }
3281 &SerializeWith(&self.r#typical_age_range)
3282 })?;
3283 } else {
3284 serialize_struct.skip_field("typicalAgeRange")?;
3285 }
3286 if !Vec::is_empty(&self.r#usage_info) {
3287 serialize_struct.serialize_field("usageInfo", {
3288 struct SerializeWith<'a>(&'a Vec<UsageInfoProperty>);
3289 impl<'a> Serialize for SerializeWith<'a> {
3290 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3291 where
3292 S: Serializer,
3293 {
3294 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3295 self.0, serializer,
3296 )
3297 }
3298 }
3299 &SerializeWith(&self.r#usage_info)
3300 })?;
3301 } else {
3302 serialize_struct.skip_field("usageInfo")?;
3303 }
3304 if !Vec::is_empty(&self.r#version) {
3305 serialize_struct.serialize_field("version", {
3306 struct SerializeWith<'a>(&'a Vec<VersionProperty>);
3307 impl<'a> Serialize for SerializeWith<'a> {
3308 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3309 where
3310 S: Serializer,
3311 {
3312 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3313 self.0, serializer,
3314 )
3315 }
3316 }
3317 &SerializeWith(&self.r#version)
3318 })?;
3319 } else {
3320 serialize_struct.skip_field("version")?;
3321 }
3322 if !Vec::is_empty(&self.r#video) {
3323 serialize_struct.serialize_field("video", {
3324 struct SerializeWith<'a>(&'a Vec<VideoProperty>);
3325 impl<'a> Serialize for SerializeWith<'a> {
3326 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3327 where
3328 S: Serializer,
3329 {
3330 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3331 self.0, serializer,
3332 )
3333 }
3334 }
3335 &SerializeWith(&self.r#video)
3336 })?;
3337 } else {
3338 serialize_struct.skip_field("video")?;
3339 }
3340 if !Vec::is_empty(&self.r#work_example) {
3341 serialize_struct.serialize_field("workExample", {
3342 struct SerializeWith<'a>(&'a Vec<WorkExampleProperty>);
3343 impl<'a> Serialize for SerializeWith<'a> {
3344 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3345 where
3346 S: Serializer,
3347 {
3348 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3349 self.0, serializer,
3350 )
3351 }
3352 }
3353 &SerializeWith(&self.r#work_example)
3354 })?;
3355 } else {
3356 serialize_struct.skip_field("workExample")?;
3357 }
3358 if !Vec::is_empty(&self.r#work_translation) {
3359 serialize_struct.serialize_field("workTranslation", {
3360 struct SerializeWith<'a>(&'a Vec<WorkTranslationProperty>);
3361 impl<'a> Serialize for SerializeWith<'a> {
3362 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3363 where
3364 S: Serializer,
3365 {
3366 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3367 self.0, serializer,
3368 )
3369 }
3370 }
3371 &SerializeWith(&self.r#work_translation)
3372 })?;
3373 } else {
3374 serialize_struct.skip_field("workTranslation")?;
3375 }
3376 if !Vec::is_empty(&self.r#actor) {
3377 serialize_struct.serialize_field("actor", {
3378 struct SerializeWith<'a>(&'a Vec<ActorProperty>);
3379 impl<'a> Serialize for SerializeWith<'a> {
3380 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3381 where
3382 S: Serializer,
3383 {
3384 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3385 self.0, serializer,
3386 )
3387 }
3388 }
3389 &SerializeWith(&self.r#actor)
3390 })?;
3391 } else {
3392 serialize_struct.skip_field("actor")?;
3393 }
3394 if !Vec::is_empty(&self.r#director) {
3395 serialize_struct.serialize_field("director", {
3396 struct SerializeWith<'a>(&'a Vec<DirectorProperty>);
3397 impl<'a> Serialize for SerializeWith<'a> {
3398 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3399 where
3400 S: Serializer,
3401 {
3402 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3403 self.0, serializer,
3404 )
3405 }
3406 }
3407 &SerializeWith(&self.r#director)
3408 })?;
3409 } else {
3410 serialize_struct.skip_field("director")?;
3411 }
3412 if !Vec::is_empty(&self.r#end_date) {
3413 serialize_struct.serialize_field("endDate", {
3414 struct SerializeWith<'a>(&'a Vec<EndDateProperty>);
3415 impl<'a> Serialize for SerializeWith<'a> {
3416 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3417 where
3418 S: Serializer,
3419 {
3420 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3421 self.0, serializer,
3422 )
3423 }
3424 }
3425 &SerializeWith(&self.r#end_date)
3426 })?;
3427 } else {
3428 serialize_struct.skip_field("endDate")?;
3429 }
3430 if !Vec::is_empty(&self.r#episode) {
3431 serialize_struct.serialize_field("episode", {
3432 struct SerializeWith<'a>(&'a Vec<EpisodeProperty>);
3433 impl<'a> Serialize for SerializeWith<'a> {
3434 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3435 where
3436 S: Serializer,
3437 {
3438 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3439 self.0, serializer,
3440 )
3441 }
3442 }
3443 &SerializeWith(&self.r#episode)
3444 })?;
3445 } else {
3446 serialize_struct.skip_field("episode")?;
3447 }
3448 if !Vec::is_empty(&self.r#episodes) {
3449 serialize_struct.serialize_field("episodes", {
3450 struct SerializeWith<'a>(&'a Vec<EpisodesProperty>);
3451 impl<'a> Serialize for SerializeWith<'a> {
3452 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3453 where
3454 S: Serializer,
3455 {
3456 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3457 self.0, serializer,
3458 )
3459 }
3460 }
3461 &SerializeWith(&self.r#episodes)
3462 })?;
3463 } else {
3464 serialize_struct.skip_field("episodes")?;
3465 }
3466 if !Vec::is_empty(&self.r#number_of_episodes) {
3467 serialize_struct.serialize_field("numberOfEpisodes", {
3468 struct SerializeWith<'a>(&'a Vec<NumberOfEpisodesProperty>);
3469 impl<'a> Serialize for SerializeWith<'a> {
3470 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3471 where
3472 S: Serializer,
3473 {
3474 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3475 self.0, serializer,
3476 )
3477 }
3478 }
3479 &SerializeWith(&self.r#number_of_episodes)
3480 })?;
3481 } else {
3482 serialize_struct.skip_field("numberOfEpisodes")?;
3483 }
3484 if !Vec::is_empty(&self.r#part_of_series) {
3485 serialize_struct.serialize_field("partOfSeries", {
3486 struct SerializeWith<'a>(&'a Vec<PartOfSeriesProperty>);
3487 impl<'a> Serialize for SerializeWith<'a> {
3488 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3489 where
3490 S: Serializer,
3491 {
3492 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3493 self.0, serializer,
3494 )
3495 }
3496 }
3497 &SerializeWith(&self.r#part_of_series)
3498 })?;
3499 } else {
3500 serialize_struct.skip_field("partOfSeries")?;
3501 }
3502 if !Vec::is_empty(&self.r#production_company) {
3503 serialize_struct.serialize_field("productionCompany", {
3504 struct SerializeWith<'a>(&'a Vec<ProductionCompanyProperty>);
3505 impl<'a> Serialize for SerializeWith<'a> {
3506 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3507 where
3508 S: Serializer,
3509 {
3510 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3511 self.0, serializer,
3512 )
3513 }
3514 }
3515 &SerializeWith(&self.r#production_company)
3516 })?;
3517 } else {
3518 serialize_struct.skip_field("productionCompany")?;
3519 }
3520 if !Vec::is_empty(&self.r#season_number) {
3521 serialize_struct.serialize_field("seasonNumber", {
3522 struct SerializeWith<'a>(&'a Vec<SeasonNumberProperty>);
3523 impl<'a> Serialize for SerializeWith<'a> {
3524 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3525 where
3526 S: Serializer,
3527 {
3528 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3529 self.0, serializer,
3530 )
3531 }
3532 }
3533 &SerializeWith(&self.r#season_number)
3534 })?;
3535 } else {
3536 serialize_struct.skip_field("seasonNumber")?;
3537 }
3538 if !Vec::is_empty(&self.r#start_date) {
3539 serialize_struct.serialize_field("startDate", {
3540 struct SerializeWith<'a>(&'a Vec<StartDateProperty>);
3541 impl<'a> Serialize for SerializeWith<'a> {
3542 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3543 where
3544 S: Serializer,
3545 {
3546 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3547 self.0, serializer,
3548 )
3549 }
3550 }
3551 &SerializeWith(&self.r#start_date)
3552 })?;
3553 } else {
3554 serialize_struct.skip_field("startDate")?;
3555 }
3556 if !Vec::is_empty(&self.r#trailer) {
3557 serialize_struct.serialize_field("trailer", {
3558 struct SerializeWith<'a>(&'a Vec<TrailerProperty>);
3559 impl<'a> Serialize for SerializeWith<'a> {
3560 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3561 where
3562 S: Serializer,
3563 {
3564 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3565 self.0, serializer,
3566 )
3567 }
3568 }
3569 &SerializeWith(&self.r#trailer)
3570 })?;
3571 } else {
3572 serialize_struct.skip_field("trailer")?;
3573 }
3574 if !Vec::is_empty(&self.r#additional_type) {
3575 serialize_struct.serialize_field("additionalType", {
3576 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
3577 impl<'a> Serialize for SerializeWith<'a> {
3578 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3579 where
3580 S: Serializer,
3581 {
3582 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3583 self.0, serializer,
3584 )
3585 }
3586 }
3587 &SerializeWith(&self.r#additional_type)
3588 })?;
3589 } else {
3590 serialize_struct.skip_field("additionalType")?;
3591 }
3592 if !Vec::is_empty(&self.r#alternate_name) {
3593 serialize_struct.serialize_field("alternateName", {
3594 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
3595 impl<'a> Serialize for SerializeWith<'a> {
3596 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3597 where
3598 S: Serializer,
3599 {
3600 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3601 self.0, serializer,
3602 )
3603 }
3604 }
3605 &SerializeWith(&self.r#alternate_name)
3606 })?;
3607 } else {
3608 serialize_struct.skip_field("alternateName")?;
3609 }
3610 if !Vec::is_empty(&self.r#description) {
3611 serialize_struct.serialize_field("description", {
3612 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
3613 impl<'a> Serialize for SerializeWith<'a> {
3614 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3615 where
3616 S: Serializer,
3617 {
3618 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3619 self.0, serializer,
3620 )
3621 }
3622 }
3623 &SerializeWith(&self.r#description)
3624 })?;
3625 } else {
3626 serialize_struct.skip_field("description")?;
3627 }
3628 if !Vec::is_empty(&self.r#disambiguating_description) {
3629 serialize_struct.serialize_field("disambiguatingDescription", {
3630 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
3631 impl<'a> Serialize for SerializeWith<'a> {
3632 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3633 where
3634 S: Serializer,
3635 {
3636 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3637 self.0, serializer,
3638 )
3639 }
3640 }
3641 &SerializeWith(&self.r#disambiguating_description)
3642 })?;
3643 } else {
3644 serialize_struct.skip_field("disambiguatingDescription")?;
3645 }
3646 if !Vec::is_empty(&self.r#identifier) {
3647 serialize_struct.serialize_field("identifier", {
3648 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
3649 impl<'a> Serialize for SerializeWith<'a> {
3650 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3651 where
3652 S: Serializer,
3653 {
3654 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3655 self.0, serializer,
3656 )
3657 }
3658 }
3659 &SerializeWith(&self.r#identifier)
3660 })?;
3661 } else {
3662 serialize_struct.skip_field("identifier")?;
3663 }
3664 if !Vec::is_empty(&self.r#image) {
3665 serialize_struct.serialize_field("image", {
3666 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
3667 impl<'a> Serialize for SerializeWith<'a> {
3668 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3669 where
3670 S: Serializer,
3671 {
3672 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3673 self.0, serializer,
3674 )
3675 }
3676 }
3677 &SerializeWith(&self.r#image)
3678 })?;
3679 } else {
3680 serialize_struct.skip_field("image")?;
3681 }
3682 if !Vec::is_empty(&self.r#main_entity_of_page) {
3683 serialize_struct.serialize_field("mainEntityOfPage", {
3684 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
3685 impl<'a> Serialize for SerializeWith<'a> {
3686 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3687 where
3688 S: Serializer,
3689 {
3690 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3691 self.0, serializer,
3692 )
3693 }
3694 }
3695 &SerializeWith(&self.r#main_entity_of_page)
3696 })?;
3697 } else {
3698 serialize_struct.skip_field("mainEntityOfPage")?;
3699 }
3700 if !Vec::is_empty(&self.r#name) {
3701 serialize_struct.serialize_field("name", {
3702 struct SerializeWith<'a>(&'a Vec<NameProperty>);
3703 impl<'a> Serialize for SerializeWith<'a> {
3704 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3705 where
3706 S: Serializer,
3707 {
3708 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3709 self.0, serializer,
3710 )
3711 }
3712 }
3713 &SerializeWith(&self.r#name)
3714 })?;
3715 } else {
3716 serialize_struct.skip_field("name")?;
3717 }
3718 if !Vec::is_empty(&self.r#potential_action) {
3719 serialize_struct.serialize_field("potentialAction", {
3720 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
3721 impl<'a> Serialize for SerializeWith<'a> {
3722 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3723 where
3724 S: Serializer,
3725 {
3726 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3727 self.0, serializer,
3728 )
3729 }
3730 }
3731 &SerializeWith(&self.r#potential_action)
3732 })?;
3733 } else {
3734 serialize_struct.skip_field("potentialAction")?;
3735 }
3736 if !Vec::is_empty(&self.r#same_as) {
3737 serialize_struct.serialize_field("sameAs", {
3738 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
3739 impl<'a> Serialize for SerializeWith<'a> {
3740 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3741 where
3742 S: Serializer,
3743 {
3744 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3745 self.0, serializer,
3746 )
3747 }
3748 }
3749 &SerializeWith(&self.r#same_as)
3750 })?;
3751 } else {
3752 serialize_struct.skip_field("sameAs")?;
3753 }
3754 if !Vec::is_empty(&self.r#subject_of) {
3755 serialize_struct.serialize_field("subjectOf", {
3756 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
3757 impl<'a> Serialize for SerializeWith<'a> {
3758 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3759 where
3760 S: Serializer,
3761 {
3762 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3763 self.0, serializer,
3764 )
3765 }
3766 }
3767 &SerializeWith(&self.r#subject_of)
3768 })?;
3769 } else {
3770 serialize_struct.skip_field("subjectOf")?;
3771 }
3772 if !Vec::is_empty(&self.r#url) {
3773 serialize_struct.serialize_field("url", {
3774 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
3775 impl<'a> Serialize for SerializeWith<'a> {
3776 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3777 where
3778 S: Serializer,
3779 {
3780 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
3781 self.0, serializer,
3782 )
3783 }
3784 }
3785 &SerializeWith(&self.r#url)
3786 })?;
3787 } else {
3788 serialize_struct.skip_field("url")?;
3789 }
3790 serialize_struct.end()
3791 }
3792 }
3793 impl<'de> Deserialize<'de> for TvSeason {
3794 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3795 where
3796 D: Deserializer<'de>,
3797 {
3798 enum Field {
3799 CountryOfOrigin,
3800 PartOfTvSeries,
3801 TitleEidr,
3802 About,
3803 Abstract,
3804 AccessMode,
3805 AccessModeSufficient,
3806 AccessibilityApi,
3807 AccessibilityControl,
3808 AccessibilityFeature,
3809 AccessibilityHazard,
3810 AccessibilitySummary,
3811 AccountablePerson,
3812 AcquireLicensePage,
3813 AggregateRating,
3814 AlternativeHeadline,
3815 ArchivedAt,
3816 Assesses,
3817 AssociatedMedia,
3818 Audience,
3819 Audio,
3820 Author,
3821 Award,
3822 Awards,
3823 Character,
3824 Citation,
3825 Comment,
3826 CommentCount,
3827 ConditionsOfAccess,
3828 ContentLocation,
3829 ContentRating,
3830 ContentReferenceTime,
3831 Contributor,
3832 CopyrightHolder,
3833 CopyrightNotice,
3834 CopyrightYear,
3835 Correction,
3836 CreativeWorkStatus,
3837 Creator,
3838 CreditText,
3839 DateCreated,
3840 DateModified,
3841 DatePublished,
3842 DiscussionUrl,
3843 EditEidr,
3844 Editor,
3845 EducationalAlignment,
3846 EducationalLevel,
3847 EducationalUse,
3848 Encoding,
3849 EncodingFormat,
3850 Encodings,
3851 ExampleOfWork,
3852 Expires,
3853 FileFormat,
3854 Funder,
3855 Funding,
3856 Genre,
3857 HasPart,
3858 Headline,
3859 InLanguage,
3860 InteractionStatistic,
3861 InteractivityType,
3862 InterpretedAsClaim,
3863 IsAccessibleForFree,
3864 IsBasedOn,
3865 IsBasedOnUrl,
3866 IsFamilyFriendly,
3867 IsPartOf,
3868 Keywords,
3869 LearningResourceType,
3870 License,
3871 LocationCreated,
3872 MainEntity,
3873 Maintainer,
3874 Material,
3875 MaterialExtent,
3876 Mentions,
3877 Offers,
3878 Pattern,
3879 Position,
3880 Producer,
3881 Provider,
3882 Publication,
3883 Publisher,
3884 PublisherImprint,
3885 PublishingPrinciples,
3886 RecordedAt,
3887 ReleasedEvent,
3888 Review,
3889 Reviews,
3890 SchemaVersion,
3891 SdDatePublished,
3892 SdLicense,
3893 SdPublisher,
3894 Size,
3895 SourceOrganization,
3896 Spatial,
3897 SpatialCoverage,
3898 Sponsor,
3899 Teaches,
3900 Temporal,
3901 TemporalCoverage,
3902 Text,
3903 Thumbnail,
3904 ThumbnailUrl,
3905 TimeRequired,
3906 TranslationOfWork,
3907 Translator,
3908 TypicalAgeRange,
3909 UsageInfo,
3910 Version,
3911 Video,
3912 WorkExample,
3913 WorkTranslation,
3914 Actor,
3915 Director,
3916 EndDate,
3917 Episode,
3918 Episodes,
3919 NumberOfEpisodes,
3920 PartOfSeries,
3921 ProductionCompany,
3922 SeasonNumber,
3923 StartDate,
3924 Trailer,
3925 AdditionalType,
3926 AlternateName,
3927 Description,
3928 DisambiguatingDescription,
3929 Identifier,
3930 Image,
3931 MainEntityOfPage,
3932 Name,
3933 PotentialAction,
3934 SameAs,
3935 SubjectOf,
3936 Url,
3937 Ignore,
3938 }
3939 struct FieldVisitor;
3940 impl<'de> Visitor<'de> for FieldVisitor {
3941 type Value = Field;
3942 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
3943 formatter.write_str("field identifier")
3944 }
3945 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
3946 where
3947 E: de::Error,
3948 {
3949 match value {
3950 "countryOfOrigin" => Ok(Field::CountryOfOrigin),
3951 "partOfTVSeries" => Ok(Field::PartOfTvSeries),
3952 "titleEIDR" => Ok(Field::TitleEidr),
3953 "about" => Ok(Field::About),
3954 "abstract" => Ok(Field::Abstract),
3955 "accessMode" => Ok(Field::AccessMode),
3956 "accessModeSufficient" => Ok(Field::AccessModeSufficient),
3957 "accessibilityAPI" => Ok(Field::AccessibilityApi),
3958 "accessibilityControl" => Ok(Field::AccessibilityControl),
3959 "accessibilityFeature" => Ok(Field::AccessibilityFeature),
3960 "accessibilityHazard" => Ok(Field::AccessibilityHazard),
3961 "accessibilitySummary" => Ok(Field::AccessibilitySummary),
3962 "accountablePerson" => Ok(Field::AccountablePerson),
3963 "acquireLicensePage" => Ok(Field::AcquireLicensePage),
3964 "aggregateRating" => Ok(Field::AggregateRating),
3965 "alternativeHeadline" => Ok(Field::AlternativeHeadline),
3966 "archivedAt" => Ok(Field::ArchivedAt),
3967 "assesses" => Ok(Field::Assesses),
3968 "associatedMedia" => Ok(Field::AssociatedMedia),
3969 "audience" => Ok(Field::Audience),
3970 "audio" => Ok(Field::Audio),
3971 "author" => Ok(Field::Author),
3972 "award" => Ok(Field::Award),
3973 "awards" => Ok(Field::Awards),
3974 "character" => Ok(Field::Character),
3975 "citation" => Ok(Field::Citation),
3976 "comment" => Ok(Field::Comment),
3977 "commentCount" => Ok(Field::CommentCount),
3978 "conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
3979 "contentLocation" => Ok(Field::ContentLocation),
3980 "contentRating" => Ok(Field::ContentRating),
3981 "contentReferenceTime" => Ok(Field::ContentReferenceTime),
3982 "contributor" => Ok(Field::Contributor),
3983 "copyrightHolder" => Ok(Field::CopyrightHolder),
3984 "copyrightNotice" => Ok(Field::CopyrightNotice),
3985 "copyrightYear" => Ok(Field::CopyrightYear),
3986 "correction" => Ok(Field::Correction),
3987 "creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
3988 "creator" => Ok(Field::Creator),
3989 "creditText" => Ok(Field::CreditText),
3990 "dateCreated" => Ok(Field::DateCreated),
3991 "dateModified" => Ok(Field::DateModified),
3992 "datePublished" => Ok(Field::DatePublished),
3993 "discussionUrl" => Ok(Field::DiscussionUrl),
3994 "editEIDR" => Ok(Field::EditEidr),
3995 "editor" => Ok(Field::Editor),
3996 "educationalAlignment" => Ok(Field::EducationalAlignment),
3997 "educationalLevel" => Ok(Field::EducationalLevel),
3998 "educationalUse" => Ok(Field::EducationalUse),
3999 "encoding" => Ok(Field::Encoding),
4000 "encodingFormat" => Ok(Field::EncodingFormat),
4001 "encodings" => Ok(Field::Encodings),
4002 "exampleOfWork" => Ok(Field::ExampleOfWork),
4003 "expires" => Ok(Field::Expires),
4004 "fileFormat" => Ok(Field::FileFormat),
4005 "funder" => Ok(Field::Funder),
4006 "funding" => Ok(Field::Funding),
4007 "genre" => Ok(Field::Genre),
4008 "hasPart" => Ok(Field::HasPart),
4009 "headline" => Ok(Field::Headline),
4010 "inLanguage" => Ok(Field::InLanguage),
4011 "interactionStatistic" => Ok(Field::InteractionStatistic),
4012 "interactivityType" => Ok(Field::InteractivityType),
4013 "interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4014 "isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4015 "isBasedOn" => Ok(Field::IsBasedOn),
4016 "isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4017 "isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4018 "isPartOf" => Ok(Field::IsPartOf),
4019 "keywords" => Ok(Field::Keywords),
4020 "learningResourceType" => Ok(Field::LearningResourceType),
4021 "license" => Ok(Field::License),
4022 "locationCreated" => Ok(Field::LocationCreated),
4023 "mainEntity" => Ok(Field::MainEntity),
4024 "maintainer" => Ok(Field::Maintainer),
4025 "material" => Ok(Field::Material),
4026 "materialExtent" => Ok(Field::MaterialExtent),
4027 "mentions" => Ok(Field::Mentions),
4028 "offers" => Ok(Field::Offers),
4029 "pattern" => Ok(Field::Pattern),
4030 "position" => Ok(Field::Position),
4031 "producer" => Ok(Field::Producer),
4032 "provider" => Ok(Field::Provider),
4033 "publication" => Ok(Field::Publication),
4034 "publisher" => Ok(Field::Publisher),
4035 "publisherImprint" => Ok(Field::PublisherImprint),
4036 "publishingPrinciples" => Ok(Field::PublishingPrinciples),
4037 "recordedAt" => Ok(Field::RecordedAt),
4038 "releasedEvent" => Ok(Field::ReleasedEvent),
4039 "review" => Ok(Field::Review),
4040 "reviews" => Ok(Field::Reviews),
4041 "schemaVersion" => Ok(Field::SchemaVersion),
4042 "sdDatePublished" => Ok(Field::SdDatePublished),
4043 "sdLicense" => Ok(Field::SdLicense),
4044 "sdPublisher" => Ok(Field::SdPublisher),
4045 "size" => Ok(Field::Size),
4046 "sourceOrganization" => Ok(Field::SourceOrganization),
4047 "spatial" => Ok(Field::Spatial),
4048 "spatialCoverage" => Ok(Field::SpatialCoverage),
4049 "sponsor" => Ok(Field::Sponsor),
4050 "teaches" => Ok(Field::Teaches),
4051 "temporal" => Ok(Field::Temporal),
4052 "temporalCoverage" => Ok(Field::TemporalCoverage),
4053 "text" => Ok(Field::Text),
4054 "thumbnail" => Ok(Field::Thumbnail),
4055 "thumbnailUrl" => Ok(Field::ThumbnailUrl),
4056 "timeRequired" => Ok(Field::TimeRequired),
4057 "translationOfWork" => Ok(Field::TranslationOfWork),
4058 "translator" => Ok(Field::Translator),
4059 "typicalAgeRange" => Ok(Field::TypicalAgeRange),
4060 "usageInfo" => Ok(Field::UsageInfo),
4061 "version" => Ok(Field::Version),
4062 "video" => Ok(Field::Video),
4063 "workExample" => Ok(Field::WorkExample),
4064 "workTranslation" => Ok(Field::WorkTranslation),
4065 "actor" => Ok(Field::Actor),
4066 "director" => Ok(Field::Director),
4067 "endDate" => Ok(Field::EndDate),
4068 "episode" => Ok(Field::Episode),
4069 "episodes" => Ok(Field::Episodes),
4070 "numberOfEpisodes" => Ok(Field::NumberOfEpisodes),
4071 "partOfSeries" => Ok(Field::PartOfSeries),
4072 "productionCompany" => Ok(Field::ProductionCompany),
4073 "seasonNumber" => Ok(Field::SeasonNumber),
4074 "startDate" => Ok(Field::StartDate),
4075 "trailer" => Ok(Field::Trailer),
4076 "additionalType" => Ok(Field::AdditionalType),
4077 "alternateName" => Ok(Field::AlternateName),
4078 "description" => Ok(Field::Description),
4079 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
4080 "identifier" => Ok(Field::Identifier),
4081 "image" => Ok(Field::Image),
4082 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
4083 "name" => Ok(Field::Name),
4084 "potentialAction" => Ok(Field::PotentialAction),
4085 "sameAs" => Ok(Field::SameAs),
4086 "subjectOf" => Ok(Field::SubjectOf),
4087 "url" => Ok(Field::Url),
4088 "id" | "type" => Ok(Field::Ignore),
4089 _ => Err(de::Error::unknown_field(value, FIELDS)),
4090 }
4091 }
4092 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
4093 where
4094 E: de::Error,
4095 {
4096 match value {
4097 b"countryOfOrigin" => Ok(Field::CountryOfOrigin),
4098 b"partOfTVSeries" => Ok(Field::PartOfTvSeries),
4099 b"titleEIDR" => Ok(Field::TitleEidr),
4100 b"about" => Ok(Field::About),
4101 b"abstract" => Ok(Field::Abstract),
4102 b"accessMode" => Ok(Field::AccessMode),
4103 b"accessModeSufficient" => Ok(Field::AccessModeSufficient),
4104 b"accessibilityAPI" => Ok(Field::AccessibilityApi),
4105 b"accessibilityControl" => Ok(Field::AccessibilityControl),
4106 b"accessibilityFeature" => Ok(Field::AccessibilityFeature),
4107 b"accessibilityHazard" => Ok(Field::AccessibilityHazard),
4108 b"accessibilitySummary" => Ok(Field::AccessibilitySummary),
4109 b"accountablePerson" => Ok(Field::AccountablePerson),
4110 b"acquireLicensePage" => Ok(Field::AcquireLicensePage),
4111 b"aggregateRating" => Ok(Field::AggregateRating),
4112 b"alternativeHeadline" => Ok(Field::AlternativeHeadline),
4113 b"archivedAt" => Ok(Field::ArchivedAt),
4114 b"assesses" => Ok(Field::Assesses),
4115 b"associatedMedia" => Ok(Field::AssociatedMedia),
4116 b"audience" => Ok(Field::Audience),
4117 b"audio" => Ok(Field::Audio),
4118 b"author" => Ok(Field::Author),
4119 b"award" => Ok(Field::Award),
4120 b"awards" => Ok(Field::Awards),
4121 b"character" => Ok(Field::Character),
4122 b"citation" => Ok(Field::Citation),
4123 b"comment" => Ok(Field::Comment),
4124 b"commentCount" => Ok(Field::CommentCount),
4125 b"conditionsOfAccess" => Ok(Field::ConditionsOfAccess),
4126 b"contentLocation" => Ok(Field::ContentLocation),
4127 b"contentRating" => Ok(Field::ContentRating),
4128 b"contentReferenceTime" => Ok(Field::ContentReferenceTime),
4129 b"contributor" => Ok(Field::Contributor),
4130 b"copyrightHolder" => Ok(Field::CopyrightHolder),
4131 b"copyrightNotice" => Ok(Field::CopyrightNotice),
4132 b"copyrightYear" => Ok(Field::CopyrightYear),
4133 b"correction" => Ok(Field::Correction),
4134 b"creativeWorkStatus" => Ok(Field::CreativeWorkStatus),
4135 b"creator" => Ok(Field::Creator),
4136 b"creditText" => Ok(Field::CreditText),
4137 b"dateCreated" => Ok(Field::DateCreated),
4138 b"dateModified" => Ok(Field::DateModified),
4139 b"datePublished" => Ok(Field::DatePublished),
4140 b"discussionUrl" => Ok(Field::DiscussionUrl),
4141 b"editEIDR" => Ok(Field::EditEidr),
4142 b"editor" => Ok(Field::Editor),
4143 b"educationalAlignment" => Ok(Field::EducationalAlignment),
4144 b"educationalLevel" => Ok(Field::EducationalLevel),
4145 b"educationalUse" => Ok(Field::EducationalUse),
4146 b"encoding" => Ok(Field::Encoding),
4147 b"encodingFormat" => Ok(Field::EncodingFormat),
4148 b"encodings" => Ok(Field::Encodings),
4149 b"exampleOfWork" => Ok(Field::ExampleOfWork),
4150 b"expires" => Ok(Field::Expires),
4151 b"fileFormat" => Ok(Field::FileFormat),
4152 b"funder" => Ok(Field::Funder),
4153 b"funding" => Ok(Field::Funding),
4154 b"genre" => Ok(Field::Genre),
4155 b"hasPart" => Ok(Field::HasPart),
4156 b"headline" => Ok(Field::Headline),
4157 b"inLanguage" => Ok(Field::InLanguage),
4158 b"interactionStatistic" => Ok(Field::InteractionStatistic),
4159 b"interactivityType" => Ok(Field::InteractivityType),
4160 b"interpretedAsClaim" => Ok(Field::InterpretedAsClaim),
4161 b"isAccessibleForFree" => Ok(Field::IsAccessibleForFree),
4162 b"isBasedOn" => Ok(Field::IsBasedOn),
4163 b"isBasedOnUrl" => Ok(Field::IsBasedOnUrl),
4164 b"isFamilyFriendly" => Ok(Field::IsFamilyFriendly),
4165 b"isPartOf" => Ok(Field::IsPartOf),
4166 b"keywords" => Ok(Field::Keywords),
4167 b"learningResourceType" => Ok(Field::LearningResourceType),
4168 b"license" => Ok(Field::License),
4169 b"locationCreated" => Ok(Field::LocationCreated),
4170 b"mainEntity" => Ok(Field::MainEntity),
4171 b"maintainer" => Ok(Field::Maintainer),
4172 b"material" => Ok(Field::Material),
4173 b"materialExtent" => Ok(Field::MaterialExtent),
4174 b"mentions" => Ok(Field::Mentions),
4175 b"offers" => Ok(Field::Offers),
4176 b"pattern" => Ok(Field::Pattern),
4177 b"position" => Ok(Field::Position),
4178 b"producer" => Ok(Field::Producer),
4179 b"provider" => Ok(Field::Provider),
4180 b"publication" => Ok(Field::Publication),
4181 b"publisher" => Ok(Field::Publisher),
4182 b"publisherImprint" => Ok(Field::PublisherImprint),
4183 b"publishingPrinciples" => Ok(Field::PublishingPrinciples),
4184 b"recordedAt" => Ok(Field::RecordedAt),
4185 b"releasedEvent" => Ok(Field::ReleasedEvent),
4186 b"review" => Ok(Field::Review),
4187 b"reviews" => Ok(Field::Reviews),
4188 b"schemaVersion" => Ok(Field::SchemaVersion),
4189 b"sdDatePublished" => Ok(Field::SdDatePublished),
4190 b"sdLicense" => Ok(Field::SdLicense),
4191 b"sdPublisher" => Ok(Field::SdPublisher),
4192 b"size" => Ok(Field::Size),
4193 b"sourceOrganization" => Ok(Field::SourceOrganization),
4194 b"spatial" => Ok(Field::Spatial),
4195 b"spatialCoverage" => Ok(Field::SpatialCoverage),
4196 b"sponsor" => Ok(Field::Sponsor),
4197 b"teaches" => Ok(Field::Teaches),
4198 b"temporal" => Ok(Field::Temporal),
4199 b"temporalCoverage" => Ok(Field::TemporalCoverage),
4200 b"text" => Ok(Field::Text),
4201 b"thumbnail" => Ok(Field::Thumbnail),
4202 b"thumbnailUrl" => Ok(Field::ThumbnailUrl),
4203 b"timeRequired" => Ok(Field::TimeRequired),
4204 b"translationOfWork" => Ok(Field::TranslationOfWork),
4205 b"translator" => Ok(Field::Translator),
4206 b"typicalAgeRange" => Ok(Field::TypicalAgeRange),
4207 b"usageInfo" => Ok(Field::UsageInfo),
4208 b"version" => Ok(Field::Version),
4209 b"video" => Ok(Field::Video),
4210 b"workExample" => Ok(Field::WorkExample),
4211 b"workTranslation" => Ok(Field::WorkTranslation),
4212 b"actor" => Ok(Field::Actor),
4213 b"director" => Ok(Field::Director),
4214 b"endDate" => Ok(Field::EndDate),
4215 b"episode" => Ok(Field::Episode),
4216 b"episodes" => Ok(Field::Episodes),
4217 b"numberOfEpisodes" => Ok(Field::NumberOfEpisodes),
4218 b"partOfSeries" => Ok(Field::PartOfSeries),
4219 b"productionCompany" => Ok(Field::ProductionCompany),
4220 b"seasonNumber" => Ok(Field::SeasonNumber),
4221 b"startDate" => Ok(Field::StartDate),
4222 b"trailer" => Ok(Field::Trailer),
4223 b"additionalType" => Ok(Field::AdditionalType),
4224 b"alternateName" => Ok(Field::AlternateName),
4225 b"description" => Ok(Field::Description),
4226 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
4227 b"identifier" => Ok(Field::Identifier),
4228 b"image" => Ok(Field::Image),
4229 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
4230 b"name" => Ok(Field::Name),
4231 b"potentialAction" => Ok(Field::PotentialAction),
4232 b"sameAs" => Ok(Field::SameAs),
4233 b"subjectOf" => Ok(Field::SubjectOf),
4234 b"url" => Ok(Field::Url),
4235 b"id" | b"type" => Ok(Field::Ignore),
4236 _ => {
4237 let value = &String::from_utf8_lossy(value);
4238 Err(de::Error::unknown_field(value, FIELDS))
4239 }
4240 }
4241 }
4242 }
4243 impl<'de> Deserialize<'de> for Field {
4244 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4245 where
4246 D: Deserializer<'de>,
4247 {
4248 deserializer.deserialize_identifier(FieldVisitor)
4249 }
4250 }
4251 struct ClassVisitor;
4252 impl<'de> Visitor<'de> for ClassVisitor {
4253 type Value = TvSeason;
4254 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
4255 formatter.write_str("schema.org schema TVSeason")
4256 }
4257 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
4258 where
4259 A: de::MapAccess<'de>,
4260 {
4261 let mut r#country_of_origin_property = None;
4262 let mut r#part_of_tv_series_property = None;
4263 let mut r#title_eidr_property = None;
4264 let mut r#about_property = None;
4265 let mut r#abstract_property = None;
4266 let mut r#access_mode_property = None;
4267 let mut r#access_mode_sufficient_property = None;
4268 let mut r#accessibility_api_property = None;
4269 let mut r#accessibility_control_property = None;
4270 let mut r#accessibility_feature_property = None;
4271 let mut r#accessibility_hazard_property = None;
4272 let mut r#accessibility_summary_property = None;
4273 let mut r#accountable_person_property = None;
4274 let mut r#acquire_license_page_property = None;
4275 let mut r#aggregate_rating_property = None;
4276 let mut r#alternative_headline_property = None;
4277 let mut r#archived_at_property = None;
4278 let mut r#assesses_property = None;
4279 let mut r#associated_media_property = None;
4280 let mut r#audience_property = None;
4281 let mut r#audio_property = None;
4282 let mut r#author_property = None;
4283 let mut r#award_property = None;
4284 let mut r#awards_property = None;
4285 let mut r#character_property = None;
4286 let mut r#citation_property = None;
4287 let mut r#comment_property = None;
4288 let mut r#comment_count_property = None;
4289 let mut r#conditions_of_access_property = None;
4290 let mut r#content_location_property = None;
4291 let mut r#content_rating_property = None;
4292 let mut r#content_reference_time_property = None;
4293 let mut r#contributor_property = None;
4294 let mut r#copyright_holder_property = None;
4295 let mut r#copyright_notice_property = None;
4296 let mut r#copyright_year_property = None;
4297 let mut r#correction_property = None;
4298 let mut r#creative_work_status_property = None;
4299 let mut r#creator_property = None;
4300 let mut r#credit_text_property = None;
4301 let mut r#date_created_property = None;
4302 let mut r#date_modified_property = None;
4303 let mut r#date_published_property = None;
4304 let mut r#discussion_url_property = None;
4305 let mut r#edit_eidr_property = None;
4306 let mut r#editor_property = None;
4307 let mut r#educational_alignment_property = None;
4308 let mut r#educational_level_property = None;
4309 let mut r#educational_use_property = None;
4310 let mut r#encoding_property = None;
4311 let mut r#encoding_format_property = None;
4312 let mut r#encodings_property = None;
4313 let mut r#example_of_work_property = None;
4314 let mut r#expires_property = None;
4315 let mut r#file_format_property = None;
4316 let mut r#funder_property = None;
4317 let mut r#funding_property = None;
4318 let mut r#genre_property = None;
4319 let mut r#has_part_property = None;
4320 let mut r#headline_property = None;
4321 let mut r#in_language_property = None;
4322 let mut r#interaction_statistic_property = None;
4323 let mut r#interactivity_type_property = None;
4324 let mut r#interpreted_as_claim_property = None;
4325 let mut r#is_accessible_for_free_property = None;
4326 let mut r#is_based_on_property = None;
4327 let mut r#is_based_on_url_property = None;
4328 let mut r#is_family_friendly_property = None;
4329 let mut r#is_part_of_property = None;
4330 let mut r#keywords_property = None;
4331 let mut r#learning_resource_type_property = None;
4332 let mut r#license_property = None;
4333 let mut r#location_created_property = None;
4334 let mut r#main_entity_property = None;
4335 let mut r#maintainer_property = None;
4336 let mut r#material_property = None;
4337 let mut r#material_extent_property = None;
4338 let mut r#mentions_property = None;
4339 let mut r#offers_property = None;
4340 let mut r#pattern_property = None;
4341 let mut r#position_property = None;
4342 let mut r#producer_property = None;
4343 let mut r#provider_property = None;
4344 let mut r#publication_property = None;
4345 let mut r#publisher_property = None;
4346 let mut r#publisher_imprint_property = None;
4347 let mut r#publishing_principles_property = None;
4348 let mut r#recorded_at_property = None;
4349 let mut r#released_event_property = None;
4350 let mut r#review_property = None;
4351 let mut r#reviews_property = None;
4352 let mut r#schema_version_property = None;
4353 let mut r#sd_date_published_property = None;
4354 let mut r#sd_license_property = None;
4355 let mut r#sd_publisher_property = None;
4356 let mut r#size_property = None;
4357 let mut r#source_organization_property = None;
4358 let mut r#spatial_property = None;
4359 let mut r#spatial_coverage_property = None;
4360 let mut r#sponsor_property = None;
4361 let mut r#teaches_property = None;
4362 let mut r#temporal_property = None;
4363 let mut r#temporal_coverage_property = None;
4364 let mut r#text_property = None;
4365 let mut r#thumbnail_property = None;
4366 let mut r#thumbnail_url_property = None;
4367 let mut r#time_required_property = None;
4368 let mut r#translation_of_work_property = None;
4369 let mut r#translator_property = None;
4370 let mut r#typical_age_range_property = None;
4371 let mut r#usage_info_property = None;
4372 let mut r#version_property = None;
4373 let mut r#video_property = None;
4374 let mut r#work_example_property = None;
4375 let mut r#work_translation_property = None;
4376 let mut r#actor_property = None;
4377 let mut r#director_property = None;
4378 let mut r#end_date_property = None;
4379 let mut r#episode_property = None;
4380 let mut r#episodes_property = None;
4381 let mut r#number_of_episodes_property = None;
4382 let mut r#part_of_series_property = None;
4383 let mut r#production_company_property = None;
4384 let mut r#season_number_property = None;
4385 let mut r#start_date_property = None;
4386 let mut r#trailer_property = None;
4387 let mut r#additional_type_property = None;
4388 let mut r#alternate_name_property = None;
4389 let mut r#description_property = None;
4390 let mut r#disambiguating_description_property = None;
4391 let mut r#identifier_property = None;
4392 let mut r#image_property = None;
4393 let mut r#main_entity_of_page_property = None;
4394 let mut r#name_property = None;
4395 let mut r#potential_action_property = None;
4396 let mut r#same_as_property = None;
4397 let mut r#subject_of_property = None;
4398 let mut r#url_property = None;
4399 while let Some(key) = map.next_key::<Field>()? {
4400 match key {
4401 Field::CountryOfOrigin => {
4402 if r#country_of_origin_property.is_some() {
4403 return Err(<A::Error as de::Error>::duplicate_field(
4404 "countryOfOrigin",
4405 ));
4406 }
4407 r#country_of_origin_property = Some({
4408 struct DeserializeWith(Vec<CountryOfOriginProperty>);
4409 impl<'de> Deserialize<'de> for DeserializeWith {
4410 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4411 where
4412 D: Deserializer<'de>,
4413 {
4414 Ok(DeserializeWith(serde_with::As::<
4415 serde_with::OneOrMany<serde_with::Same>,
4416 >::deserialize(deserializer)?))
4417 }
4418 }
4419 match map.next_value::<DeserializeWith>() {
4420 Ok(deserialize_with) => deserialize_with.0,
4421 Err(err) => {
4422 return Err(err);
4423 }
4424 }
4425 });
4426 }
4427 Field::PartOfTvSeries => {
4428 if r#part_of_tv_series_property.is_some() {
4429 return Err(<A::Error as de::Error>::duplicate_field(
4430 "partOfTVSeries",
4431 ));
4432 }
4433 r#part_of_tv_series_property = Some({
4434 struct DeserializeWith(Vec<PartOfTvSeriesProperty>);
4435 impl<'de> Deserialize<'de> for DeserializeWith {
4436 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4437 where
4438 D: Deserializer<'de>,
4439 {
4440 Ok(DeserializeWith(serde_with::As::<
4441 serde_with::OneOrMany<serde_with::Same>,
4442 >::deserialize(deserializer)?))
4443 }
4444 }
4445 match map.next_value::<DeserializeWith>() {
4446 Ok(deserialize_with) => deserialize_with.0,
4447 Err(err) => {
4448 return Err(err);
4449 }
4450 }
4451 });
4452 }
4453 Field::TitleEidr => {
4454 if r#title_eidr_property.is_some() {
4455 return Err(<A::Error as de::Error>::duplicate_field(
4456 "titleEIDR",
4457 ));
4458 }
4459 r#title_eidr_property = Some({
4460 struct DeserializeWith(Vec<TitleEidrProperty>);
4461 impl<'de> Deserialize<'de> for DeserializeWith {
4462 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4463 where
4464 D: Deserializer<'de>,
4465 {
4466 Ok(DeserializeWith(serde_with::As::<
4467 serde_with::OneOrMany<serde_with::Same>,
4468 >::deserialize(deserializer)?))
4469 }
4470 }
4471 match map.next_value::<DeserializeWith>() {
4472 Ok(deserialize_with) => deserialize_with.0,
4473 Err(err) => {
4474 return Err(err);
4475 }
4476 }
4477 });
4478 }
4479 Field::About => {
4480 if r#about_property.is_some() {
4481 return Err(<A::Error as de::Error>::duplicate_field("about"));
4482 }
4483 r#about_property = Some({
4484 struct DeserializeWith(Vec<AboutProperty>);
4485 impl<'de> Deserialize<'de> for DeserializeWith {
4486 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4487 where
4488 D: Deserializer<'de>,
4489 {
4490 Ok(DeserializeWith(serde_with::As::<
4491 serde_with::OneOrMany<serde_with::Same>,
4492 >::deserialize(deserializer)?))
4493 }
4494 }
4495 match map.next_value::<DeserializeWith>() {
4496 Ok(deserialize_with) => deserialize_with.0,
4497 Err(err) => {
4498 return Err(err);
4499 }
4500 }
4501 });
4502 }
4503 Field::Abstract => {
4504 if r#abstract_property.is_some() {
4505 return Err(<A::Error as de::Error>::duplicate_field(
4506 "abstract",
4507 ));
4508 }
4509 r#abstract_property = Some({
4510 struct DeserializeWith(Vec<AbstractProperty>);
4511 impl<'de> Deserialize<'de> for DeserializeWith {
4512 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4513 where
4514 D: Deserializer<'de>,
4515 {
4516 Ok(DeserializeWith(serde_with::As::<
4517 serde_with::OneOrMany<serde_with::Same>,
4518 >::deserialize(deserializer)?))
4519 }
4520 }
4521 match map.next_value::<DeserializeWith>() {
4522 Ok(deserialize_with) => deserialize_with.0,
4523 Err(err) => {
4524 return Err(err);
4525 }
4526 }
4527 });
4528 }
4529 Field::AccessMode => {
4530 if r#access_mode_property.is_some() {
4531 return Err(<A::Error as de::Error>::duplicate_field(
4532 "accessMode",
4533 ));
4534 }
4535 r#access_mode_property = Some({
4536 struct DeserializeWith(Vec<AccessModeProperty>);
4537 impl<'de> Deserialize<'de> for DeserializeWith {
4538 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4539 where
4540 D: Deserializer<'de>,
4541 {
4542 Ok(DeserializeWith(serde_with::As::<
4543 serde_with::OneOrMany<serde_with::Same>,
4544 >::deserialize(deserializer)?))
4545 }
4546 }
4547 match map.next_value::<DeserializeWith>() {
4548 Ok(deserialize_with) => deserialize_with.0,
4549 Err(err) => {
4550 return Err(err);
4551 }
4552 }
4553 });
4554 }
4555 Field::AccessModeSufficient => {
4556 if r#access_mode_sufficient_property.is_some() {
4557 return Err(<A::Error as de::Error>::duplicate_field(
4558 "accessModeSufficient",
4559 ));
4560 }
4561 r#access_mode_sufficient_property = Some({
4562 struct DeserializeWith(Vec<AccessModeSufficientProperty>);
4563 impl<'de> Deserialize<'de> for DeserializeWith {
4564 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4565 where
4566 D: Deserializer<'de>,
4567 {
4568 Ok(DeserializeWith(serde_with::As::<
4569 serde_with::OneOrMany<serde_with::Same>,
4570 >::deserialize(deserializer)?))
4571 }
4572 }
4573 match map.next_value::<DeserializeWith>() {
4574 Ok(deserialize_with) => deserialize_with.0,
4575 Err(err) => {
4576 return Err(err);
4577 }
4578 }
4579 });
4580 }
4581 Field::AccessibilityApi => {
4582 if r#accessibility_api_property.is_some() {
4583 return Err(<A::Error as de::Error>::duplicate_field(
4584 "accessibilityAPI",
4585 ));
4586 }
4587 r#accessibility_api_property = Some({
4588 struct DeserializeWith(Vec<AccessibilityApiProperty>);
4589 impl<'de> Deserialize<'de> for DeserializeWith {
4590 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4591 where
4592 D: Deserializer<'de>,
4593 {
4594 Ok(DeserializeWith(serde_with::As::<
4595 serde_with::OneOrMany<serde_with::Same>,
4596 >::deserialize(deserializer)?))
4597 }
4598 }
4599 match map.next_value::<DeserializeWith>() {
4600 Ok(deserialize_with) => deserialize_with.0,
4601 Err(err) => {
4602 return Err(err);
4603 }
4604 }
4605 });
4606 }
4607 Field::AccessibilityControl => {
4608 if r#accessibility_control_property.is_some() {
4609 return Err(<A::Error as de::Error>::duplicate_field(
4610 "accessibilityControl",
4611 ));
4612 }
4613 r#accessibility_control_property = Some({
4614 struct DeserializeWith(Vec<AccessibilityControlProperty>);
4615 impl<'de> Deserialize<'de> for DeserializeWith {
4616 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4617 where
4618 D: Deserializer<'de>,
4619 {
4620 Ok(DeserializeWith(serde_with::As::<
4621 serde_with::OneOrMany<serde_with::Same>,
4622 >::deserialize(deserializer)?))
4623 }
4624 }
4625 match map.next_value::<DeserializeWith>() {
4626 Ok(deserialize_with) => deserialize_with.0,
4627 Err(err) => {
4628 return Err(err);
4629 }
4630 }
4631 });
4632 }
4633 Field::AccessibilityFeature => {
4634 if r#accessibility_feature_property.is_some() {
4635 return Err(<A::Error as de::Error>::duplicate_field(
4636 "accessibilityFeature",
4637 ));
4638 }
4639 r#accessibility_feature_property = Some({
4640 struct DeserializeWith(Vec<AccessibilityFeatureProperty>);
4641 impl<'de> Deserialize<'de> for DeserializeWith {
4642 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4643 where
4644 D: Deserializer<'de>,
4645 {
4646 Ok(DeserializeWith(serde_with::As::<
4647 serde_with::OneOrMany<serde_with::Same>,
4648 >::deserialize(deserializer)?))
4649 }
4650 }
4651 match map.next_value::<DeserializeWith>() {
4652 Ok(deserialize_with) => deserialize_with.0,
4653 Err(err) => {
4654 return Err(err);
4655 }
4656 }
4657 });
4658 }
4659 Field::AccessibilityHazard => {
4660 if r#accessibility_hazard_property.is_some() {
4661 return Err(<A::Error as de::Error>::duplicate_field(
4662 "accessibilityHazard",
4663 ));
4664 }
4665 r#accessibility_hazard_property = Some({
4666 struct DeserializeWith(Vec<AccessibilityHazardProperty>);
4667 impl<'de> Deserialize<'de> for DeserializeWith {
4668 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4669 where
4670 D: Deserializer<'de>,
4671 {
4672 Ok(DeserializeWith(serde_with::As::<
4673 serde_with::OneOrMany<serde_with::Same>,
4674 >::deserialize(deserializer)?))
4675 }
4676 }
4677 match map.next_value::<DeserializeWith>() {
4678 Ok(deserialize_with) => deserialize_with.0,
4679 Err(err) => {
4680 return Err(err);
4681 }
4682 }
4683 });
4684 }
4685 Field::AccessibilitySummary => {
4686 if r#accessibility_summary_property.is_some() {
4687 return Err(<A::Error as de::Error>::duplicate_field(
4688 "accessibilitySummary",
4689 ));
4690 }
4691 r#accessibility_summary_property = Some({
4692 struct DeserializeWith(Vec<AccessibilitySummaryProperty>);
4693 impl<'de> Deserialize<'de> for DeserializeWith {
4694 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4695 where
4696 D: Deserializer<'de>,
4697 {
4698 Ok(DeserializeWith(serde_with::As::<
4699 serde_with::OneOrMany<serde_with::Same>,
4700 >::deserialize(deserializer)?))
4701 }
4702 }
4703 match map.next_value::<DeserializeWith>() {
4704 Ok(deserialize_with) => deserialize_with.0,
4705 Err(err) => {
4706 return Err(err);
4707 }
4708 }
4709 });
4710 }
4711 Field::AccountablePerson => {
4712 if r#accountable_person_property.is_some() {
4713 return Err(<A::Error as de::Error>::duplicate_field(
4714 "accountablePerson",
4715 ));
4716 }
4717 r#accountable_person_property = Some({
4718 struct DeserializeWith(Vec<AccountablePersonProperty>);
4719 impl<'de> Deserialize<'de> for DeserializeWith {
4720 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4721 where
4722 D: Deserializer<'de>,
4723 {
4724 Ok(DeserializeWith(serde_with::As::<
4725 serde_with::OneOrMany<serde_with::Same>,
4726 >::deserialize(deserializer)?))
4727 }
4728 }
4729 match map.next_value::<DeserializeWith>() {
4730 Ok(deserialize_with) => deserialize_with.0,
4731 Err(err) => {
4732 return Err(err);
4733 }
4734 }
4735 });
4736 }
4737 Field::AcquireLicensePage => {
4738 if r#acquire_license_page_property.is_some() {
4739 return Err(<A::Error as de::Error>::duplicate_field(
4740 "acquireLicensePage",
4741 ));
4742 }
4743 r#acquire_license_page_property = Some({
4744 struct DeserializeWith(Vec<AcquireLicensePageProperty>);
4745 impl<'de> Deserialize<'de> for DeserializeWith {
4746 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4747 where
4748 D: Deserializer<'de>,
4749 {
4750 Ok(DeserializeWith(serde_with::As::<
4751 serde_with::OneOrMany<serde_with::Same>,
4752 >::deserialize(deserializer)?))
4753 }
4754 }
4755 match map.next_value::<DeserializeWith>() {
4756 Ok(deserialize_with) => deserialize_with.0,
4757 Err(err) => {
4758 return Err(err);
4759 }
4760 }
4761 });
4762 }
4763 Field::AggregateRating => {
4764 if r#aggregate_rating_property.is_some() {
4765 return Err(<A::Error as de::Error>::duplicate_field(
4766 "aggregateRating",
4767 ));
4768 }
4769 r#aggregate_rating_property = Some({
4770 struct DeserializeWith(Vec<AggregateRatingProperty>);
4771 impl<'de> Deserialize<'de> for DeserializeWith {
4772 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4773 where
4774 D: Deserializer<'de>,
4775 {
4776 Ok(DeserializeWith(serde_with::As::<
4777 serde_with::OneOrMany<serde_with::Same>,
4778 >::deserialize(deserializer)?))
4779 }
4780 }
4781 match map.next_value::<DeserializeWith>() {
4782 Ok(deserialize_with) => deserialize_with.0,
4783 Err(err) => {
4784 return Err(err);
4785 }
4786 }
4787 });
4788 }
4789 Field::AlternativeHeadline => {
4790 if r#alternative_headline_property.is_some() {
4791 return Err(<A::Error as de::Error>::duplicate_field(
4792 "alternativeHeadline",
4793 ));
4794 }
4795 r#alternative_headline_property = Some({
4796 struct DeserializeWith(Vec<AlternativeHeadlineProperty>);
4797 impl<'de> Deserialize<'de> for DeserializeWith {
4798 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4799 where
4800 D: Deserializer<'de>,
4801 {
4802 Ok(DeserializeWith(serde_with::As::<
4803 serde_with::OneOrMany<serde_with::Same>,
4804 >::deserialize(deserializer)?))
4805 }
4806 }
4807 match map.next_value::<DeserializeWith>() {
4808 Ok(deserialize_with) => deserialize_with.0,
4809 Err(err) => {
4810 return Err(err);
4811 }
4812 }
4813 });
4814 }
4815 Field::ArchivedAt => {
4816 if r#archived_at_property.is_some() {
4817 return Err(<A::Error as de::Error>::duplicate_field(
4818 "archivedAt",
4819 ));
4820 }
4821 r#archived_at_property = Some({
4822 struct DeserializeWith(Vec<ArchivedAtProperty>);
4823 impl<'de> Deserialize<'de> for DeserializeWith {
4824 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4825 where
4826 D: Deserializer<'de>,
4827 {
4828 Ok(DeserializeWith(serde_with::As::<
4829 serde_with::OneOrMany<serde_with::Same>,
4830 >::deserialize(deserializer)?))
4831 }
4832 }
4833 match map.next_value::<DeserializeWith>() {
4834 Ok(deserialize_with) => deserialize_with.0,
4835 Err(err) => {
4836 return Err(err);
4837 }
4838 }
4839 });
4840 }
4841 Field::Assesses => {
4842 if r#assesses_property.is_some() {
4843 return Err(<A::Error as de::Error>::duplicate_field(
4844 "assesses",
4845 ));
4846 }
4847 r#assesses_property = Some({
4848 struct DeserializeWith(Vec<AssessesProperty>);
4849 impl<'de> Deserialize<'de> for DeserializeWith {
4850 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4851 where
4852 D: Deserializer<'de>,
4853 {
4854 Ok(DeserializeWith(serde_with::As::<
4855 serde_with::OneOrMany<serde_with::Same>,
4856 >::deserialize(deserializer)?))
4857 }
4858 }
4859 match map.next_value::<DeserializeWith>() {
4860 Ok(deserialize_with) => deserialize_with.0,
4861 Err(err) => {
4862 return Err(err);
4863 }
4864 }
4865 });
4866 }
4867 Field::AssociatedMedia => {
4868 if r#associated_media_property.is_some() {
4869 return Err(<A::Error as de::Error>::duplicate_field(
4870 "associatedMedia",
4871 ));
4872 }
4873 r#associated_media_property = Some({
4874 struct DeserializeWith(Vec<AssociatedMediaProperty>);
4875 impl<'de> Deserialize<'de> for DeserializeWith {
4876 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4877 where
4878 D: Deserializer<'de>,
4879 {
4880 Ok(DeserializeWith(serde_with::As::<
4881 serde_with::OneOrMany<serde_with::Same>,
4882 >::deserialize(deserializer)?))
4883 }
4884 }
4885 match map.next_value::<DeserializeWith>() {
4886 Ok(deserialize_with) => deserialize_with.0,
4887 Err(err) => {
4888 return Err(err);
4889 }
4890 }
4891 });
4892 }
4893 Field::Audience => {
4894 if r#audience_property.is_some() {
4895 return Err(<A::Error as de::Error>::duplicate_field(
4896 "audience",
4897 ));
4898 }
4899 r#audience_property = Some({
4900 struct DeserializeWith(Vec<AudienceProperty>);
4901 impl<'de> Deserialize<'de> for DeserializeWith {
4902 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4903 where
4904 D: Deserializer<'de>,
4905 {
4906 Ok(DeserializeWith(serde_with::As::<
4907 serde_with::OneOrMany<serde_with::Same>,
4908 >::deserialize(deserializer)?))
4909 }
4910 }
4911 match map.next_value::<DeserializeWith>() {
4912 Ok(deserialize_with) => deserialize_with.0,
4913 Err(err) => {
4914 return Err(err);
4915 }
4916 }
4917 });
4918 }
4919 Field::Audio => {
4920 if r#audio_property.is_some() {
4921 return Err(<A::Error as de::Error>::duplicate_field("audio"));
4922 }
4923 r#audio_property = Some({
4924 struct DeserializeWith(Vec<AudioProperty>);
4925 impl<'de> Deserialize<'de> for DeserializeWith {
4926 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4927 where
4928 D: Deserializer<'de>,
4929 {
4930 Ok(DeserializeWith(serde_with::As::<
4931 serde_with::OneOrMany<serde_with::Same>,
4932 >::deserialize(deserializer)?))
4933 }
4934 }
4935 match map.next_value::<DeserializeWith>() {
4936 Ok(deserialize_with) => deserialize_with.0,
4937 Err(err) => {
4938 return Err(err);
4939 }
4940 }
4941 });
4942 }
4943 Field::Author => {
4944 if r#author_property.is_some() {
4945 return Err(<A::Error as de::Error>::duplicate_field("author"));
4946 }
4947 r#author_property = Some({
4948 struct DeserializeWith(Vec<AuthorProperty>);
4949 impl<'de> Deserialize<'de> for DeserializeWith {
4950 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4951 where
4952 D: Deserializer<'de>,
4953 {
4954 Ok(DeserializeWith(serde_with::As::<
4955 serde_with::OneOrMany<serde_with::Same>,
4956 >::deserialize(deserializer)?))
4957 }
4958 }
4959 match map.next_value::<DeserializeWith>() {
4960 Ok(deserialize_with) => deserialize_with.0,
4961 Err(err) => {
4962 return Err(err);
4963 }
4964 }
4965 });
4966 }
4967 Field::Award => {
4968 if r#award_property.is_some() {
4969 return Err(<A::Error as de::Error>::duplicate_field("award"));
4970 }
4971 r#award_property = Some({
4972 struct DeserializeWith(Vec<AwardProperty>);
4973 impl<'de> Deserialize<'de> for DeserializeWith {
4974 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4975 where
4976 D: Deserializer<'de>,
4977 {
4978 Ok(DeserializeWith(serde_with::As::<
4979 serde_with::OneOrMany<serde_with::Same>,
4980 >::deserialize(deserializer)?))
4981 }
4982 }
4983 match map.next_value::<DeserializeWith>() {
4984 Ok(deserialize_with) => deserialize_with.0,
4985 Err(err) => {
4986 return Err(err);
4987 }
4988 }
4989 });
4990 }
4991 Field::Awards => {
4992 if r#awards_property.is_some() {
4993 return Err(<A::Error as de::Error>::duplicate_field("awards"));
4994 }
4995 r#awards_property = Some({
4996 struct DeserializeWith(Vec<AwardsProperty>);
4997 impl<'de> Deserialize<'de> for DeserializeWith {
4998 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
4999 where
5000 D: Deserializer<'de>,
5001 {
5002 Ok(DeserializeWith(serde_with::As::<
5003 serde_with::OneOrMany<serde_with::Same>,
5004 >::deserialize(deserializer)?))
5005 }
5006 }
5007 match map.next_value::<DeserializeWith>() {
5008 Ok(deserialize_with) => deserialize_with.0,
5009 Err(err) => {
5010 return Err(err);
5011 }
5012 }
5013 });
5014 }
5015 Field::Character => {
5016 if r#character_property.is_some() {
5017 return Err(<A::Error as de::Error>::duplicate_field(
5018 "character",
5019 ));
5020 }
5021 r#character_property = Some({
5022 struct DeserializeWith(Vec<CharacterProperty>);
5023 impl<'de> Deserialize<'de> for DeserializeWith {
5024 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5025 where
5026 D: Deserializer<'de>,
5027 {
5028 Ok(DeserializeWith(serde_with::As::<
5029 serde_with::OneOrMany<serde_with::Same>,
5030 >::deserialize(deserializer)?))
5031 }
5032 }
5033 match map.next_value::<DeserializeWith>() {
5034 Ok(deserialize_with) => deserialize_with.0,
5035 Err(err) => {
5036 return Err(err);
5037 }
5038 }
5039 });
5040 }
5041 Field::Citation => {
5042 if r#citation_property.is_some() {
5043 return Err(<A::Error as de::Error>::duplicate_field(
5044 "citation",
5045 ));
5046 }
5047 r#citation_property = Some({
5048 struct DeserializeWith(Vec<CitationProperty>);
5049 impl<'de> Deserialize<'de> for DeserializeWith {
5050 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5051 where
5052 D: Deserializer<'de>,
5053 {
5054 Ok(DeserializeWith(serde_with::As::<
5055 serde_with::OneOrMany<serde_with::Same>,
5056 >::deserialize(deserializer)?))
5057 }
5058 }
5059 match map.next_value::<DeserializeWith>() {
5060 Ok(deserialize_with) => deserialize_with.0,
5061 Err(err) => {
5062 return Err(err);
5063 }
5064 }
5065 });
5066 }
5067 Field::Comment => {
5068 if r#comment_property.is_some() {
5069 return Err(<A::Error as de::Error>::duplicate_field(
5070 "comment",
5071 ));
5072 }
5073 r#comment_property = Some({
5074 struct DeserializeWith(Vec<CommentProperty>);
5075 impl<'de> Deserialize<'de> for DeserializeWith {
5076 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5077 where
5078 D: Deserializer<'de>,
5079 {
5080 Ok(DeserializeWith(serde_with::As::<
5081 serde_with::OneOrMany<serde_with::Same>,
5082 >::deserialize(deserializer)?))
5083 }
5084 }
5085 match map.next_value::<DeserializeWith>() {
5086 Ok(deserialize_with) => deserialize_with.0,
5087 Err(err) => {
5088 return Err(err);
5089 }
5090 }
5091 });
5092 }
5093 Field::CommentCount => {
5094 if r#comment_count_property.is_some() {
5095 return Err(<A::Error as de::Error>::duplicate_field(
5096 "commentCount",
5097 ));
5098 }
5099 r#comment_count_property = Some({
5100 struct DeserializeWith(Vec<CommentCountProperty>);
5101 impl<'de> Deserialize<'de> for DeserializeWith {
5102 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5103 where
5104 D: Deserializer<'de>,
5105 {
5106 Ok(DeserializeWith(serde_with::As::<
5107 serde_with::OneOrMany<serde_with::Same>,
5108 >::deserialize(deserializer)?))
5109 }
5110 }
5111 match map.next_value::<DeserializeWith>() {
5112 Ok(deserialize_with) => deserialize_with.0,
5113 Err(err) => {
5114 return Err(err);
5115 }
5116 }
5117 });
5118 }
5119 Field::ConditionsOfAccess => {
5120 if r#conditions_of_access_property.is_some() {
5121 return Err(<A::Error as de::Error>::duplicate_field(
5122 "conditionsOfAccess",
5123 ));
5124 }
5125 r#conditions_of_access_property = Some({
5126 struct DeserializeWith(Vec<ConditionsOfAccessProperty>);
5127 impl<'de> Deserialize<'de> for DeserializeWith {
5128 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5129 where
5130 D: Deserializer<'de>,
5131 {
5132 Ok(DeserializeWith(serde_with::As::<
5133 serde_with::OneOrMany<serde_with::Same>,
5134 >::deserialize(deserializer)?))
5135 }
5136 }
5137 match map.next_value::<DeserializeWith>() {
5138 Ok(deserialize_with) => deserialize_with.0,
5139 Err(err) => {
5140 return Err(err);
5141 }
5142 }
5143 });
5144 }
5145 Field::ContentLocation => {
5146 if r#content_location_property.is_some() {
5147 return Err(<A::Error as de::Error>::duplicate_field(
5148 "contentLocation",
5149 ));
5150 }
5151 r#content_location_property = Some({
5152 struct DeserializeWith(Vec<ContentLocationProperty>);
5153 impl<'de> Deserialize<'de> for DeserializeWith {
5154 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5155 where
5156 D: Deserializer<'de>,
5157 {
5158 Ok(DeserializeWith(serde_with::As::<
5159 serde_with::OneOrMany<serde_with::Same>,
5160 >::deserialize(deserializer)?))
5161 }
5162 }
5163 match map.next_value::<DeserializeWith>() {
5164 Ok(deserialize_with) => deserialize_with.0,
5165 Err(err) => {
5166 return Err(err);
5167 }
5168 }
5169 });
5170 }
5171 Field::ContentRating => {
5172 if r#content_rating_property.is_some() {
5173 return Err(<A::Error as de::Error>::duplicate_field(
5174 "contentRating",
5175 ));
5176 }
5177 r#content_rating_property = Some({
5178 struct DeserializeWith(Vec<ContentRatingProperty>);
5179 impl<'de> Deserialize<'de> for DeserializeWith {
5180 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5181 where
5182 D: Deserializer<'de>,
5183 {
5184 Ok(DeserializeWith(serde_with::As::<
5185 serde_with::OneOrMany<serde_with::Same>,
5186 >::deserialize(deserializer)?))
5187 }
5188 }
5189 match map.next_value::<DeserializeWith>() {
5190 Ok(deserialize_with) => deserialize_with.0,
5191 Err(err) => {
5192 return Err(err);
5193 }
5194 }
5195 });
5196 }
5197 Field::ContentReferenceTime => {
5198 if r#content_reference_time_property.is_some() {
5199 return Err(<A::Error as de::Error>::duplicate_field(
5200 "contentReferenceTime",
5201 ));
5202 }
5203 r#content_reference_time_property = Some({
5204 struct DeserializeWith(Vec<ContentReferenceTimeProperty>);
5205 impl<'de> Deserialize<'de> for DeserializeWith {
5206 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5207 where
5208 D: Deserializer<'de>,
5209 {
5210 Ok(DeserializeWith(serde_with::As::<
5211 serde_with::OneOrMany<serde_with::Same>,
5212 >::deserialize(deserializer)?))
5213 }
5214 }
5215 match map.next_value::<DeserializeWith>() {
5216 Ok(deserialize_with) => deserialize_with.0,
5217 Err(err) => {
5218 return Err(err);
5219 }
5220 }
5221 });
5222 }
5223 Field::Contributor => {
5224 if r#contributor_property.is_some() {
5225 return Err(<A::Error as de::Error>::duplicate_field(
5226 "contributor",
5227 ));
5228 }
5229 r#contributor_property = Some({
5230 struct DeserializeWith(Vec<ContributorProperty>);
5231 impl<'de> Deserialize<'de> for DeserializeWith {
5232 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5233 where
5234 D: Deserializer<'de>,
5235 {
5236 Ok(DeserializeWith(serde_with::As::<
5237 serde_with::OneOrMany<serde_with::Same>,
5238 >::deserialize(deserializer)?))
5239 }
5240 }
5241 match map.next_value::<DeserializeWith>() {
5242 Ok(deserialize_with) => deserialize_with.0,
5243 Err(err) => {
5244 return Err(err);
5245 }
5246 }
5247 });
5248 }
5249 Field::CopyrightHolder => {
5250 if r#copyright_holder_property.is_some() {
5251 return Err(<A::Error as de::Error>::duplicate_field(
5252 "copyrightHolder",
5253 ));
5254 }
5255 r#copyright_holder_property = Some({
5256 struct DeserializeWith(Vec<CopyrightHolderProperty>);
5257 impl<'de> Deserialize<'de> for DeserializeWith {
5258 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5259 where
5260 D: Deserializer<'de>,
5261 {
5262 Ok(DeserializeWith(serde_with::As::<
5263 serde_with::OneOrMany<serde_with::Same>,
5264 >::deserialize(deserializer)?))
5265 }
5266 }
5267 match map.next_value::<DeserializeWith>() {
5268 Ok(deserialize_with) => deserialize_with.0,
5269 Err(err) => {
5270 return Err(err);
5271 }
5272 }
5273 });
5274 }
5275 Field::CopyrightNotice => {
5276 if r#copyright_notice_property.is_some() {
5277 return Err(<A::Error as de::Error>::duplicate_field(
5278 "copyrightNotice",
5279 ));
5280 }
5281 r#copyright_notice_property = Some({
5282 struct DeserializeWith(Vec<CopyrightNoticeProperty>);
5283 impl<'de> Deserialize<'de> for DeserializeWith {
5284 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5285 where
5286 D: Deserializer<'de>,
5287 {
5288 Ok(DeserializeWith(serde_with::As::<
5289 serde_with::OneOrMany<serde_with::Same>,
5290 >::deserialize(deserializer)?))
5291 }
5292 }
5293 match map.next_value::<DeserializeWith>() {
5294 Ok(deserialize_with) => deserialize_with.0,
5295 Err(err) => {
5296 return Err(err);
5297 }
5298 }
5299 });
5300 }
5301 Field::CopyrightYear => {
5302 if r#copyright_year_property.is_some() {
5303 return Err(<A::Error as de::Error>::duplicate_field(
5304 "copyrightYear",
5305 ));
5306 }
5307 r#copyright_year_property = Some({
5308 struct DeserializeWith(Vec<CopyrightYearProperty>);
5309 impl<'de> Deserialize<'de> for DeserializeWith {
5310 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5311 where
5312 D: Deserializer<'de>,
5313 {
5314 Ok(DeserializeWith(serde_with::As::<
5315 serde_with::OneOrMany<serde_with::Same>,
5316 >::deserialize(deserializer)?))
5317 }
5318 }
5319 match map.next_value::<DeserializeWith>() {
5320 Ok(deserialize_with) => deserialize_with.0,
5321 Err(err) => {
5322 return Err(err);
5323 }
5324 }
5325 });
5326 }
5327 Field::Correction => {
5328 if r#correction_property.is_some() {
5329 return Err(<A::Error as de::Error>::duplicate_field(
5330 "correction",
5331 ));
5332 }
5333 r#correction_property = Some({
5334 struct DeserializeWith(Vec<CorrectionProperty>);
5335 impl<'de> Deserialize<'de> for DeserializeWith {
5336 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5337 where
5338 D: Deserializer<'de>,
5339 {
5340 Ok(DeserializeWith(serde_with::As::<
5341 serde_with::OneOrMany<serde_with::Same>,
5342 >::deserialize(deserializer)?))
5343 }
5344 }
5345 match map.next_value::<DeserializeWith>() {
5346 Ok(deserialize_with) => deserialize_with.0,
5347 Err(err) => {
5348 return Err(err);
5349 }
5350 }
5351 });
5352 }
5353 Field::CreativeWorkStatus => {
5354 if r#creative_work_status_property.is_some() {
5355 return Err(<A::Error as de::Error>::duplicate_field(
5356 "creativeWorkStatus",
5357 ));
5358 }
5359 r#creative_work_status_property = Some({
5360 struct DeserializeWith(Vec<CreativeWorkStatusProperty>);
5361 impl<'de> Deserialize<'de> for DeserializeWith {
5362 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5363 where
5364 D: Deserializer<'de>,
5365 {
5366 Ok(DeserializeWith(serde_with::As::<
5367 serde_with::OneOrMany<serde_with::Same>,
5368 >::deserialize(deserializer)?))
5369 }
5370 }
5371 match map.next_value::<DeserializeWith>() {
5372 Ok(deserialize_with) => deserialize_with.0,
5373 Err(err) => {
5374 return Err(err);
5375 }
5376 }
5377 });
5378 }
5379 Field::Creator => {
5380 if r#creator_property.is_some() {
5381 return Err(<A::Error as de::Error>::duplicate_field(
5382 "creator",
5383 ));
5384 }
5385 r#creator_property = Some({
5386 struct DeserializeWith(Vec<CreatorProperty>);
5387 impl<'de> Deserialize<'de> for DeserializeWith {
5388 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5389 where
5390 D: Deserializer<'de>,
5391 {
5392 Ok(DeserializeWith(serde_with::As::<
5393 serde_with::OneOrMany<serde_with::Same>,
5394 >::deserialize(deserializer)?))
5395 }
5396 }
5397 match map.next_value::<DeserializeWith>() {
5398 Ok(deserialize_with) => deserialize_with.0,
5399 Err(err) => {
5400 return Err(err);
5401 }
5402 }
5403 });
5404 }
5405 Field::CreditText => {
5406 if r#credit_text_property.is_some() {
5407 return Err(<A::Error as de::Error>::duplicate_field(
5408 "creditText",
5409 ));
5410 }
5411 r#credit_text_property = Some({
5412 struct DeserializeWith(Vec<CreditTextProperty>);
5413 impl<'de> Deserialize<'de> for DeserializeWith {
5414 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5415 where
5416 D: Deserializer<'de>,
5417 {
5418 Ok(DeserializeWith(serde_with::As::<
5419 serde_with::OneOrMany<serde_with::Same>,
5420 >::deserialize(deserializer)?))
5421 }
5422 }
5423 match map.next_value::<DeserializeWith>() {
5424 Ok(deserialize_with) => deserialize_with.0,
5425 Err(err) => {
5426 return Err(err);
5427 }
5428 }
5429 });
5430 }
5431 Field::DateCreated => {
5432 if r#date_created_property.is_some() {
5433 return Err(<A::Error as de::Error>::duplicate_field(
5434 "dateCreated",
5435 ));
5436 }
5437 r#date_created_property = Some({
5438 struct DeserializeWith(Vec<DateCreatedProperty>);
5439 impl<'de> Deserialize<'de> for DeserializeWith {
5440 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5441 where
5442 D: Deserializer<'de>,
5443 {
5444 Ok(DeserializeWith(serde_with::As::<
5445 serde_with::OneOrMany<serde_with::Same>,
5446 >::deserialize(deserializer)?))
5447 }
5448 }
5449 match map.next_value::<DeserializeWith>() {
5450 Ok(deserialize_with) => deserialize_with.0,
5451 Err(err) => {
5452 return Err(err);
5453 }
5454 }
5455 });
5456 }
5457 Field::DateModified => {
5458 if r#date_modified_property.is_some() {
5459 return Err(<A::Error as de::Error>::duplicate_field(
5460 "dateModified",
5461 ));
5462 }
5463 r#date_modified_property = Some({
5464 struct DeserializeWith(Vec<DateModifiedProperty>);
5465 impl<'de> Deserialize<'de> for DeserializeWith {
5466 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5467 where
5468 D: Deserializer<'de>,
5469 {
5470 Ok(DeserializeWith(serde_with::As::<
5471 serde_with::OneOrMany<serde_with::Same>,
5472 >::deserialize(deserializer)?))
5473 }
5474 }
5475 match map.next_value::<DeserializeWith>() {
5476 Ok(deserialize_with) => deserialize_with.0,
5477 Err(err) => {
5478 return Err(err);
5479 }
5480 }
5481 });
5482 }
5483 Field::DatePublished => {
5484 if r#date_published_property.is_some() {
5485 return Err(<A::Error as de::Error>::duplicate_field(
5486 "datePublished",
5487 ));
5488 }
5489 r#date_published_property = Some({
5490 struct DeserializeWith(Vec<DatePublishedProperty>);
5491 impl<'de> Deserialize<'de> for DeserializeWith {
5492 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5493 where
5494 D: Deserializer<'de>,
5495 {
5496 Ok(DeserializeWith(serde_with::As::<
5497 serde_with::OneOrMany<serde_with::Same>,
5498 >::deserialize(deserializer)?))
5499 }
5500 }
5501 match map.next_value::<DeserializeWith>() {
5502 Ok(deserialize_with) => deserialize_with.0,
5503 Err(err) => {
5504 return Err(err);
5505 }
5506 }
5507 });
5508 }
5509 Field::DiscussionUrl => {
5510 if r#discussion_url_property.is_some() {
5511 return Err(<A::Error as de::Error>::duplicate_field(
5512 "discussionUrl",
5513 ));
5514 }
5515 r#discussion_url_property = Some({
5516 struct DeserializeWith(Vec<DiscussionUrlProperty>);
5517 impl<'de> Deserialize<'de> for DeserializeWith {
5518 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5519 where
5520 D: Deserializer<'de>,
5521 {
5522 Ok(DeserializeWith(serde_with::As::<
5523 serde_with::OneOrMany<serde_with::Same>,
5524 >::deserialize(deserializer)?))
5525 }
5526 }
5527 match map.next_value::<DeserializeWith>() {
5528 Ok(deserialize_with) => deserialize_with.0,
5529 Err(err) => {
5530 return Err(err);
5531 }
5532 }
5533 });
5534 }
5535 Field::EditEidr => {
5536 if r#edit_eidr_property.is_some() {
5537 return Err(<A::Error as de::Error>::duplicate_field(
5538 "editEIDR",
5539 ));
5540 }
5541 r#edit_eidr_property = Some({
5542 struct DeserializeWith(Vec<EditEidrProperty>);
5543 impl<'de> Deserialize<'de> for DeserializeWith {
5544 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5545 where
5546 D: Deserializer<'de>,
5547 {
5548 Ok(DeserializeWith(serde_with::As::<
5549 serde_with::OneOrMany<serde_with::Same>,
5550 >::deserialize(deserializer)?))
5551 }
5552 }
5553 match map.next_value::<DeserializeWith>() {
5554 Ok(deserialize_with) => deserialize_with.0,
5555 Err(err) => {
5556 return Err(err);
5557 }
5558 }
5559 });
5560 }
5561 Field::Editor => {
5562 if r#editor_property.is_some() {
5563 return Err(<A::Error as de::Error>::duplicate_field("editor"));
5564 }
5565 r#editor_property = Some({
5566 struct DeserializeWith(Vec<EditorProperty>);
5567 impl<'de> Deserialize<'de> for DeserializeWith {
5568 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5569 where
5570 D: Deserializer<'de>,
5571 {
5572 Ok(DeserializeWith(serde_with::As::<
5573 serde_with::OneOrMany<serde_with::Same>,
5574 >::deserialize(deserializer)?))
5575 }
5576 }
5577 match map.next_value::<DeserializeWith>() {
5578 Ok(deserialize_with) => deserialize_with.0,
5579 Err(err) => {
5580 return Err(err);
5581 }
5582 }
5583 });
5584 }
5585 Field::EducationalAlignment => {
5586 if r#educational_alignment_property.is_some() {
5587 return Err(<A::Error as de::Error>::duplicate_field(
5588 "educationalAlignment",
5589 ));
5590 }
5591 r#educational_alignment_property = Some({
5592 struct DeserializeWith(Vec<EducationalAlignmentProperty>);
5593 impl<'de> Deserialize<'de> for DeserializeWith {
5594 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5595 where
5596 D: Deserializer<'de>,
5597 {
5598 Ok(DeserializeWith(serde_with::As::<
5599 serde_with::OneOrMany<serde_with::Same>,
5600 >::deserialize(deserializer)?))
5601 }
5602 }
5603 match map.next_value::<DeserializeWith>() {
5604 Ok(deserialize_with) => deserialize_with.0,
5605 Err(err) => {
5606 return Err(err);
5607 }
5608 }
5609 });
5610 }
5611 Field::EducationalLevel => {
5612 if r#educational_level_property.is_some() {
5613 return Err(<A::Error as de::Error>::duplicate_field(
5614 "educationalLevel",
5615 ));
5616 }
5617 r#educational_level_property = Some({
5618 struct DeserializeWith(Vec<EducationalLevelProperty>);
5619 impl<'de> Deserialize<'de> for DeserializeWith {
5620 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5621 where
5622 D: Deserializer<'de>,
5623 {
5624 Ok(DeserializeWith(serde_with::As::<
5625 serde_with::OneOrMany<serde_with::Same>,
5626 >::deserialize(deserializer)?))
5627 }
5628 }
5629 match map.next_value::<DeserializeWith>() {
5630 Ok(deserialize_with) => deserialize_with.0,
5631 Err(err) => {
5632 return Err(err);
5633 }
5634 }
5635 });
5636 }
5637 Field::EducationalUse => {
5638 if r#educational_use_property.is_some() {
5639 return Err(<A::Error as de::Error>::duplicate_field(
5640 "educationalUse",
5641 ));
5642 }
5643 r#educational_use_property = Some({
5644 struct DeserializeWith(Vec<EducationalUseProperty>);
5645 impl<'de> Deserialize<'de> for DeserializeWith {
5646 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5647 where
5648 D: Deserializer<'de>,
5649 {
5650 Ok(DeserializeWith(serde_with::As::<
5651 serde_with::OneOrMany<serde_with::Same>,
5652 >::deserialize(deserializer)?))
5653 }
5654 }
5655 match map.next_value::<DeserializeWith>() {
5656 Ok(deserialize_with) => deserialize_with.0,
5657 Err(err) => {
5658 return Err(err);
5659 }
5660 }
5661 });
5662 }
5663 Field::Encoding => {
5664 if r#encoding_property.is_some() {
5665 return Err(<A::Error as de::Error>::duplicate_field(
5666 "encoding",
5667 ));
5668 }
5669 r#encoding_property = Some({
5670 struct DeserializeWith(Vec<EncodingProperty>);
5671 impl<'de> Deserialize<'de> for DeserializeWith {
5672 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5673 where
5674 D: Deserializer<'de>,
5675 {
5676 Ok(DeserializeWith(serde_with::As::<
5677 serde_with::OneOrMany<serde_with::Same>,
5678 >::deserialize(deserializer)?))
5679 }
5680 }
5681 match map.next_value::<DeserializeWith>() {
5682 Ok(deserialize_with) => deserialize_with.0,
5683 Err(err) => {
5684 return Err(err);
5685 }
5686 }
5687 });
5688 }
5689 Field::EncodingFormat => {
5690 if r#encoding_format_property.is_some() {
5691 return Err(<A::Error as de::Error>::duplicate_field(
5692 "encodingFormat",
5693 ));
5694 }
5695 r#encoding_format_property = Some({
5696 struct DeserializeWith(Vec<EncodingFormatProperty>);
5697 impl<'de> Deserialize<'de> for DeserializeWith {
5698 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5699 where
5700 D: Deserializer<'de>,
5701 {
5702 Ok(DeserializeWith(serde_with::As::<
5703 serde_with::OneOrMany<serde_with::Same>,
5704 >::deserialize(deserializer)?))
5705 }
5706 }
5707 match map.next_value::<DeserializeWith>() {
5708 Ok(deserialize_with) => deserialize_with.0,
5709 Err(err) => {
5710 return Err(err);
5711 }
5712 }
5713 });
5714 }
5715 Field::Encodings => {
5716 if r#encodings_property.is_some() {
5717 return Err(<A::Error as de::Error>::duplicate_field(
5718 "encodings",
5719 ));
5720 }
5721 r#encodings_property = Some({
5722 struct DeserializeWith(Vec<EncodingsProperty>);
5723 impl<'de> Deserialize<'de> for DeserializeWith {
5724 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5725 where
5726 D: Deserializer<'de>,
5727 {
5728 Ok(DeserializeWith(serde_with::As::<
5729 serde_with::OneOrMany<serde_with::Same>,
5730 >::deserialize(deserializer)?))
5731 }
5732 }
5733 match map.next_value::<DeserializeWith>() {
5734 Ok(deserialize_with) => deserialize_with.0,
5735 Err(err) => {
5736 return Err(err);
5737 }
5738 }
5739 });
5740 }
5741 Field::ExampleOfWork => {
5742 if r#example_of_work_property.is_some() {
5743 return Err(<A::Error as de::Error>::duplicate_field(
5744 "exampleOfWork",
5745 ));
5746 }
5747 r#example_of_work_property = Some({
5748 struct DeserializeWith(Vec<ExampleOfWorkProperty>);
5749 impl<'de> Deserialize<'de> for DeserializeWith {
5750 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5751 where
5752 D: Deserializer<'de>,
5753 {
5754 Ok(DeserializeWith(serde_with::As::<
5755 serde_with::OneOrMany<serde_with::Same>,
5756 >::deserialize(deserializer)?))
5757 }
5758 }
5759 match map.next_value::<DeserializeWith>() {
5760 Ok(deserialize_with) => deserialize_with.0,
5761 Err(err) => {
5762 return Err(err);
5763 }
5764 }
5765 });
5766 }
5767 Field::Expires => {
5768 if r#expires_property.is_some() {
5769 return Err(<A::Error as de::Error>::duplicate_field(
5770 "expires",
5771 ));
5772 }
5773 r#expires_property = Some({
5774 struct DeserializeWith(Vec<ExpiresProperty>);
5775 impl<'de> Deserialize<'de> for DeserializeWith {
5776 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5777 where
5778 D: Deserializer<'de>,
5779 {
5780 Ok(DeserializeWith(serde_with::As::<
5781 serde_with::OneOrMany<serde_with::Same>,
5782 >::deserialize(deserializer)?))
5783 }
5784 }
5785 match map.next_value::<DeserializeWith>() {
5786 Ok(deserialize_with) => deserialize_with.0,
5787 Err(err) => {
5788 return Err(err);
5789 }
5790 }
5791 });
5792 }
5793 Field::FileFormat => {
5794 if r#file_format_property.is_some() {
5795 return Err(<A::Error as de::Error>::duplicate_field(
5796 "fileFormat",
5797 ));
5798 }
5799 r#file_format_property = Some({
5800 struct DeserializeWith(Vec<FileFormatProperty>);
5801 impl<'de> Deserialize<'de> for DeserializeWith {
5802 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5803 where
5804 D: Deserializer<'de>,
5805 {
5806 Ok(DeserializeWith(serde_with::As::<
5807 serde_with::OneOrMany<serde_with::Same>,
5808 >::deserialize(deserializer)?))
5809 }
5810 }
5811 match map.next_value::<DeserializeWith>() {
5812 Ok(deserialize_with) => deserialize_with.0,
5813 Err(err) => {
5814 return Err(err);
5815 }
5816 }
5817 });
5818 }
5819 Field::Funder => {
5820 if r#funder_property.is_some() {
5821 return Err(<A::Error as de::Error>::duplicate_field("funder"));
5822 }
5823 r#funder_property = Some({
5824 struct DeserializeWith(Vec<FunderProperty>);
5825 impl<'de> Deserialize<'de> for DeserializeWith {
5826 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5827 where
5828 D: Deserializer<'de>,
5829 {
5830 Ok(DeserializeWith(serde_with::As::<
5831 serde_with::OneOrMany<serde_with::Same>,
5832 >::deserialize(deserializer)?))
5833 }
5834 }
5835 match map.next_value::<DeserializeWith>() {
5836 Ok(deserialize_with) => deserialize_with.0,
5837 Err(err) => {
5838 return Err(err);
5839 }
5840 }
5841 });
5842 }
5843 Field::Funding => {
5844 if r#funding_property.is_some() {
5845 return Err(<A::Error as de::Error>::duplicate_field(
5846 "funding",
5847 ));
5848 }
5849 r#funding_property = Some({
5850 struct DeserializeWith(Vec<FundingProperty>);
5851 impl<'de> Deserialize<'de> for DeserializeWith {
5852 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5853 where
5854 D: Deserializer<'de>,
5855 {
5856 Ok(DeserializeWith(serde_with::As::<
5857 serde_with::OneOrMany<serde_with::Same>,
5858 >::deserialize(deserializer)?))
5859 }
5860 }
5861 match map.next_value::<DeserializeWith>() {
5862 Ok(deserialize_with) => deserialize_with.0,
5863 Err(err) => {
5864 return Err(err);
5865 }
5866 }
5867 });
5868 }
5869 Field::Genre => {
5870 if r#genre_property.is_some() {
5871 return Err(<A::Error as de::Error>::duplicate_field("genre"));
5872 }
5873 r#genre_property = Some({
5874 struct DeserializeWith(Vec<GenreProperty>);
5875 impl<'de> Deserialize<'de> for DeserializeWith {
5876 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5877 where
5878 D: Deserializer<'de>,
5879 {
5880 Ok(DeserializeWith(serde_with::As::<
5881 serde_with::OneOrMany<serde_with::Same>,
5882 >::deserialize(deserializer)?))
5883 }
5884 }
5885 match map.next_value::<DeserializeWith>() {
5886 Ok(deserialize_with) => deserialize_with.0,
5887 Err(err) => {
5888 return Err(err);
5889 }
5890 }
5891 });
5892 }
5893 Field::HasPart => {
5894 if r#has_part_property.is_some() {
5895 return Err(<A::Error as de::Error>::duplicate_field(
5896 "hasPart",
5897 ));
5898 }
5899 r#has_part_property = Some({
5900 struct DeserializeWith(Vec<HasPartProperty>);
5901 impl<'de> Deserialize<'de> for DeserializeWith {
5902 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5903 where
5904 D: Deserializer<'de>,
5905 {
5906 Ok(DeserializeWith(serde_with::As::<
5907 serde_with::OneOrMany<serde_with::Same>,
5908 >::deserialize(deserializer)?))
5909 }
5910 }
5911 match map.next_value::<DeserializeWith>() {
5912 Ok(deserialize_with) => deserialize_with.0,
5913 Err(err) => {
5914 return Err(err);
5915 }
5916 }
5917 });
5918 }
5919 Field::Headline => {
5920 if r#headline_property.is_some() {
5921 return Err(<A::Error as de::Error>::duplicate_field(
5922 "headline",
5923 ));
5924 }
5925 r#headline_property = Some({
5926 struct DeserializeWith(Vec<HeadlineProperty>);
5927 impl<'de> Deserialize<'de> for DeserializeWith {
5928 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5929 where
5930 D: Deserializer<'de>,
5931 {
5932 Ok(DeserializeWith(serde_with::As::<
5933 serde_with::OneOrMany<serde_with::Same>,
5934 >::deserialize(deserializer)?))
5935 }
5936 }
5937 match map.next_value::<DeserializeWith>() {
5938 Ok(deserialize_with) => deserialize_with.0,
5939 Err(err) => {
5940 return Err(err);
5941 }
5942 }
5943 });
5944 }
5945 Field::InLanguage => {
5946 if r#in_language_property.is_some() {
5947 return Err(<A::Error as de::Error>::duplicate_field(
5948 "inLanguage",
5949 ));
5950 }
5951 r#in_language_property = Some({
5952 struct DeserializeWith(Vec<InLanguageProperty>);
5953 impl<'de> Deserialize<'de> for DeserializeWith {
5954 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5955 where
5956 D: Deserializer<'de>,
5957 {
5958 Ok(DeserializeWith(serde_with::As::<
5959 serde_with::OneOrMany<serde_with::Same>,
5960 >::deserialize(deserializer)?))
5961 }
5962 }
5963 match map.next_value::<DeserializeWith>() {
5964 Ok(deserialize_with) => deserialize_with.0,
5965 Err(err) => {
5966 return Err(err);
5967 }
5968 }
5969 });
5970 }
5971 Field::InteractionStatistic => {
5972 if r#interaction_statistic_property.is_some() {
5973 return Err(<A::Error as de::Error>::duplicate_field(
5974 "interactionStatistic",
5975 ));
5976 }
5977 r#interaction_statistic_property = Some({
5978 struct DeserializeWith(Vec<InteractionStatisticProperty>);
5979 impl<'de> Deserialize<'de> for DeserializeWith {
5980 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
5981 where
5982 D: Deserializer<'de>,
5983 {
5984 Ok(DeserializeWith(serde_with::As::<
5985 serde_with::OneOrMany<serde_with::Same>,
5986 >::deserialize(deserializer)?))
5987 }
5988 }
5989 match map.next_value::<DeserializeWith>() {
5990 Ok(deserialize_with) => deserialize_with.0,
5991 Err(err) => {
5992 return Err(err);
5993 }
5994 }
5995 });
5996 }
5997 Field::InteractivityType => {
5998 if r#interactivity_type_property.is_some() {
5999 return Err(<A::Error as de::Error>::duplicate_field(
6000 "interactivityType",
6001 ));
6002 }
6003 r#interactivity_type_property = Some({
6004 struct DeserializeWith(Vec<InteractivityTypeProperty>);
6005 impl<'de> Deserialize<'de> for DeserializeWith {
6006 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6007 where
6008 D: Deserializer<'de>,
6009 {
6010 Ok(DeserializeWith(serde_with::As::<
6011 serde_with::OneOrMany<serde_with::Same>,
6012 >::deserialize(deserializer)?))
6013 }
6014 }
6015 match map.next_value::<DeserializeWith>() {
6016 Ok(deserialize_with) => deserialize_with.0,
6017 Err(err) => {
6018 return Err(err);
6019 }
6020 }
6021 });
6022 }
6023 Field::InterpretedAsClaim => {
6024 if r#interpreted_as_claim_property.is_some() {
6025 return Err(<A::Error as de::Error>::duplicate_field(
6026 "interpretedAsClaim",
6027 ));
6028 }
6029 r#interpreted_as_claim_property = Some({
6030 struct DeserializeWith(Vec<InterpretedAsClaimProperty>);
6031 impl<'de> Deserialize<'de> for DeserializeWith {
6032 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6033 where
6034 D: Deserializer<'de>,
6035 {
6036 Ok(DeserializeWith(serde_with::As::<
6037 serde_with::OneOrMany<serde_with::Same>,
6038 >::deserialize(deserializer)?))
6039 }
6040 }
6041 match map.next_value::<DeserializeWith>() {
6042 Ok(deserialize_with) => deserialize_with.0,
6043 Err(err) => {
6044 return Err(err);
6045 }
6046 }
6047 });
6048 }
6049 Field::IsAccessibleForFree => {
6050 if r#is_accessible_for_free_property.is_some() {
6051 return Err(<A::Error as de::Error>::duplicate_field(
6052 "isAccessibleForFree",
6053 ));
6054 }
6055 r#is_accessible_for_free_property = Some({
6056 struct DeserializeWith(Vec<IsAccessibleForFreeProperty>);
6057 impl<'de> Deserialize<'de> for DeserializeWith {
6058 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6059 where
6060 D: Deserializer<'de>,
6061 {
6062 Ok(DeserializeWith(serde_with::As::<
6063 serde_with::OneOrMany<serde_with::Same>,
6064 >::deserialize(deserializer)?))
6065 }
6066 }
6067 match map.next_value::<DeserializeWith>() {
6068 Ok(deserialize_with) => deserialize_with.0,
6069 Err(err) => {
6070 return Err(err);
6071 }
6072 }
6073 });
6074 }
6075 Field::IsBasedOn => {
6076 if r#is_based_on_property.is_some() {
6077 return Err(<A::Error as de::Error>::duplicate_field(
6078 "isBasedOn",
6079 ));
6080 }
6081 r#is_based_on_property = Some({
6082 struct DeserializeWith(Vec<IsBasedOnProperty>);
6083 impl<'de> Deserialize<'de> for DeserializeWith {
6084 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6085 where
6086 D: Deserializer<'de>,
6087 {
6088 Ok(DeserializeWith(serde_with::As::<
6089 serde_with::OneOrMany<serde_with::Same>,
6090 >::deserialize(deserializer)?))
6091 }
6092 }
6093 match map.next_value::<DeserializeWith>() {
6094 Ok(deserialize_with) => deserialize_with.0,
6095 Err(err) => {
6096 return Err(err);
6097 }
6098 }
6099 });
6100 }
6101 Field::IsBasedOnUrl => {
6102 if r#is_based_on_url_property.is_some() {
6103 return Err(<A::Error as de::Error>::duplicate_field(
6104 "isBasedOnUrl",
6105 ));
6106 }
6107 r#is_based_on_url_property = Some({
6108 struct DeserializeWith(Vec<IsBasedOnUrlProperty>);
6109 impl<'de> Deserialize<'de> for DeserializeWith {
6110 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6111 where
6112 D: Deserializer<'de>,
6113 {
6114 Ok(DeserializeWith(serde_with::As::<
6115 serde_with::OneOrMany<serde_with::Same>,
6116 >::deserialize(deserializer)?))
6117 }
6118 }
6119 match map.next_value::<DeserializeWith>() {
6120 Ok(deserialize_with) => deserialize_with.0,
6121 Err(err) => {
6122 return Err(err);
6123 }
6124 }
6125 });
6126 }
6127 Field::IsFamilyFriendly => {
6128 if r#is_family_friendly_property.is_some() {
6129 return Err(<A::Error as de::Error>::duplicate_field(
6130 "isFamilyFriendly",
6131 ));
6132 }
6133 r#is_family_friendly_property = Some({
6134 struct DeserializeWith(Vec<IsFamilyFriendlyProperty>);
6135 impl<'de> Deserialize<'de> for DeserializeWith {
6136 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6137 where
6138 D: Deserializer<'de>,
6139 {
6140 Ok(DeserializeWith(serde_with::As::<
6141 serde_with::OneOrMany<serde_with::Same>,
6142 >::deserialize(deserializer)?))
6143 }
6144 }
6145 match map.next_value::<DeserializeWith>() {
6146 Ok(deserialize_with) => deserialize_with.0,
6147 Err(err) => {
6148 return Err(err);
6149 }
6150 }
6151 });
6152 }
6153 Field::IsPartOf => {
6154 if r#is_part_of_property.is_some() {
6155 return Err(<A::Error as de::Error>::duplicate_field(
6156 "isPartOf",
6157 ));
6158 }
6159 r#is_part_of_property = Some({
6160 struct DeserializeWith(Vec<IsPartOfProperty>);
6161 impl<'de> Deserialize<'de> for DeserializeWith {
6162 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6163 where
6164 D: Deserializer<'de>,
6165 {
6166 Ok(DeserializeWith(serde_with::As::<
6167 serde_with::OneOrMany<serde_with::Same>,
6168 >::deserialize(deserializer)?))
6169 }
6170 }
6171 match map.next_value::<DeserializeWith>() {
6172 Ok(deserialize_with) => deserialize_with.0,
6173 Err(err) => {
6174 return Err(err);
6175 }
6176 }
6177 });
6178 }
6179 Field::Keywords => {
6180 if r#keywords_property.is_some() {
6181 return Err(<A::Error as de::Error>::duplicate_field(
6182 "keywords",
6183 ));
6184 }
6185 r#keywords_property = Some({
6186 struct DeserializeWith(Vec<KeywordsProperty>);
6187 impl<'de> Deserialize<'de> for DeserializeWith {
6188 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6189 where
6190 D: Deserializer<'de>,
6191 {
6192 Ok(DeserializeWith(serde_with::As::<
6193 serde_with::OneOrMany<serde_with::Same>,
6194 >::deserialize(deserializer)?))
6195 }
6196 }
6197 match map.next_value::<DeserializeWith>() {
6198 Ok(deserialize_with) => deserialize_with.0,
6199 Err(err) => {
6200 return Err(err);
6201 }
6202 }
6203 });
6204 }
6205 Field::LearningResourceType => {
6206 if r#learning_resource_type_property.is_some() {
6207 return Err(<A::Error as de::Error>::duplicate_field(
6208 "learningResourceType",
6209 ));
6210 }
6211 r#learning_resource_type_property = Some({
6212 struct DeserializeWith(Vec<LearningResourceTypeProperty>);
6213 impl<'de> Deserialize<'de> for DeserializeWith {
6214 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6215 where
6216 D: Deserializer<'de>,
6217 {
6218 Ok(DeserializeWith(serde_with::As::<
6219 serde_with::OneOrMany<serde_with::Same>,
6220 >::deserialize(deserializer)?))
6221 }
6222 }
6223 match map.next_value::<DeserializeWith>() {
6224 Ok(deserialize_with) => deserialize_with.0,
6225 Err(err) => {
6226 return Err(err);
6227 }
6228 }
6229 });
6230 }
6231 Field::License => {
6232 if r#license_property.is_some() {
6233 return Err(<A::Error as de::Error>::duplicate_field(
6234 "license",
6235 ));
6236 }
6237 r#license_property = Some({
6238 struct DeserializeWith(Vec<LicenseProperty>);
6239 impl<'de> Deserialize<'de> for DeserializeWith {
6240 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6241 where
6242 D: Deserializer<'de>,
6243 {
6244 Ok(DeserializeWith(serde_with::As::<
6245 serde_with::OneOrMany<serde_with::Same>,
6246 >::deserialize(deserializer)?))
6247 }
6248 }
6249 match map.next_value::<DeserializeWith>() {
6250 Ok(deserialize_with) => deserialize_with.0,
6251 Err(err) => {
6252 return Err(err);
6253 }
6254 }
6255 });
6256 }
6257 Field::LocationCreated => {
6258 if r#location_created_property.is_some() {
6259 return Err(<A::Error as de::Error>::duplicate_field(
6260 "locationCreated",
6261 ));
6262 }
6263 r#location_created_property = Some({
6264 struct DeserializeWith(Vec<LocationCreatedProperty>);
6265 impl<'de> Deserialize<'de> for DeserializeWith {
6266 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6267 where
6268 D: Deserializer<'de>,
6269 {
6270 Ok(DeserializeWith(serde_with::As::<
6271 serde_with::OneOrMany<serde_with::Same>,
6272 >::deserialize(deserializer)?))
6273 }
6274 }
6275 match map.next_value::<DeserializeWith>() {
6276 Ok(deserialize_with) => deserialize_with.0,
6277 Err(err) => {
6278 return Err(err);
6279 }
6280 }
6281 });
6282 }
6283 Field::MainEntity => {
6284 if r#main_entity_property.is_some() {
6285 return Err(<A::Error as de::Error>::duplicate_field(
6286 "mainEntity",
6287 ));
6288 }
6289 r#main_entity_property = Some({
6290 struct DeserializeWith(Vec<MainEntityProperty>);
6291 impl<'de> Deserialize<'de> for DeserializeWith {
6292 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6293 where
6294 D: Deserializer<'de>,
6295 {
6296 Ok(DeserializeWith(serde_with::As::<
6297 serde_with::OneOrMany<serde_with::Same>,
6298 >::deserialize(deserializer)?))
6299 }
6300 }
6301 match map.next_value::<DeserializeWith>() {
6302 Ok(deserialize_with) => deserialize_with.0,
6303 Err(err) => {
6304 return Err(err);
6305 }
6306 }
6307 });
6308 }
6309 Field::Maintainer => {
6310 if r#maintainer_property.is_some() {
6311 return Err(<A::Error as de::Error>::duplicate_field(
6312 "maintainer",
6313 ));
6314 }
6315 r#maintainer_property = Some({
6316 struct DeserializeWith(Vec<MaintainerProperty>);
6317 impl<'de> Deserialize<'de> for DeserializeWith {
6318 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6319 where
6320 D: Deserializer<'de>,
6321 {
6322 Ok(DeserializeWith(serde_with::As::<
6323 serde_with::OneOrMany<serde_with::Same>,
6324 >::deserialize(deserializer)?))
6325 }
6326 }
6327 match map.next_value::<DeserializeWith>() {
6328 Ok(deserialize_with) => deserialize_with.0,
6329 Err(err) => {
6330 return Err(err);
6331 }
6332 }
6333 });
6334 }
6335 Field::Material => {
6336 if r#material_property.is_some() {
6337 return Err(<A::Error as de::Error>::duplicate_field(
6338 "material",
6339 ));
6340 }
6341 r#material_property = Some({
6342 struct DeserializeWith(Vec<MaterialProperty>);
6343 impl<'de> Deserialize<'de> for DeserializeWith {
6344 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6345 where
6346 D: Deserializer<'de>,
6347 {
6348 Ok(DeserializeWith(serde_with::As::<
6349 serde_with::OneOrMany<serde_with::Same>,
6350 >::deserialize(deserializer)?))
6351 }
6352 }
6353 match map.next_value::<DeserializeWith>() {
6354 Ok(deserialize_with) => deserialize_with.0,
6355 Err(err) => {
6356 return Err(err);
6357 }
6358 }
6359 });
6360 }
6361 Field::MaterialExtent => {
6362 if r#material_extent_property.is_some() {
6363 return Err(<A::Error as de::Error>::duplicate_field(
6364 "materialExtent",
6365 ));
6366 }
6367 r#material_extent_property = Some({
6368 struct DeserializeWith(Vec<MaterialExtentProperty>);
6369 impl<'de> Deserialize<'de> for DeserializeWith {
6370 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6371 where
6372 D: Deserializer<'de>,
6373 {
6374 Ok(DeserializeWith(serde_with::As::<
6375 serde_with::OneOrMany<serde_with::Same>,
6376 >::deserialize(deserializer)?))
6377 }
6378 }
6379 match map.next_value::<DeserializeWith>() {
6380 Ok(deserialize_with) => deserialize_with.0,
6381 Err(err) => {
6382 return Err(err);
6383 }
6384 }
6385 });
6386 }
6387 Field::Mentions => {
6388 if r#mentions_property.is_some() {
6389 return Err(<A::Error as de::Error>::duplicate_field(
6390 "mentions",
6391 ));
6392 }
6393 r#mentions_property = Some({
6394 struct DeserializeWith(Vec<MentionsProperty>);
6395 impl<'de> Deserialize<'de> for DeserializeWith {
6396 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6397 where
6398 D: Deserializer<'de>,
6399 {
6400 Ok(DeserializeWith(serde_with::As::<
6401 serde_with::OneOrMany<serde_with::Same>,
6402 >::deserialize(deserializer)?))
6403 }
6404 }
6405 match map.next_value::<DeserializeWith>() {
6406 Ok(deserialize_with) => deserialize_with.0,
6407 Err(err) => {
6408 return Err(err);
6409 }
6410 }
6411 });
6412 }
6413 Field::Offers => {
6414 if r#offers_property.is_some() {
6415 return Err(<A::Error as de::Error>::duplicate_field("offers"));
6416 }
6417 r#offers_property = Some({
6418 struct DeserializeWith(Vec<OffersProperty>);
6419 impl<'de> Deserialize<'de> for DeserializeWith {
6420 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6421 where
6422 D: Deserializer<'de>,
6423 {
6424 Ok(DeserializeWith(serde_with::As::<
6425 serde_with::OneOrMany<serde_with::Same>,
6426 >::deserialize(deserializer)?))
6427 }
6428 }
6429 match map.next_value::<DeserializeWith>() {
6430 Ok(deserialize_with) => deserialize_with.0,
6431 Err(err) => {
6432 return Err(err);
6433 }
6434 }
6435 });
6436 }
6437 Field::Pattern => {
6438 if r#pattern_property.is_some() {
6439 return Err(<A::Error as de::Error>::duplicate_field(
6440 "pattern",
6441 ));
6442 }
6443 r#pattern_property = Some({
6444 struct DeserializeWith(Vec<PatternProperty>);
6445 impl<'de> Deserialize<'de> for DeserializeWith {
6446 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6447 where
6448 D: Deserializer<'de>,
6449 {
6450 Ok(DeserializeWith(serde_with::As::<
6451 serde_with::OneOrMany<serde_with::Same>,
6452 >::deserialize(deserializer)?))
6453 }
6454 }
6455 match map.next_value::<DeserializeWith>() {
6456 Ok(deserialize_with) => deserialize_with.0,
6457 Err(err) => {
6458 return Err(err);
6459 }
6460 }
6461 });
6462 }
6463 Field::Position => {
6464 if r#position_property.is_some() {
6465 return Err(<A::Error as de::Error>::duplicate_field(
6466 "position",
6467 ));
6468 }
6469 r#position_property = Some({
6470 struct DeserializeWith(Vec<PositionProperty>);
6471 impl<'de> Deserialize<'de> for DeserializeWith {
6472 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6473 where
6474 D: Deserializer<'de>,
6475 {
6476 Ok(DeserializeWith(serde_with::As::<
6477 serde_with::OneOrMany<serde_with::Same>,
6478 >::deserialize(deserializer)?))
6479 }
6480 }
6481 match map.next_value::<DeserializeWith>() {
6482 Ok(deserialize_with) => deserialize_with.0,
6483 Err(err) => {
6484 return Err(err);
6485 }
6486 }
6487 });
6488 }
6489 Field::Producer => {
6490 if r#producer_property.is_some() {
6491 return Err(<A::Error as de::Error>::duplicate_field(
6492 "producer",
6493 ));
6494 }
6495 r#producer_property = Some({
6496 struct DeserializeWith(Vec<ProducerProperty>);
6497 impl<'de> Deserialize<'de> for DeserializeWith {
6498 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6499 where
6500 D: Deserializer<'de>,
6501 {
6502 Ok(DeserializeWith(serde_with::As::<
6503 serde_with::OneOrMany<serde_with::Same>,
6504 >::deserialize(deserializer)?))
6505 }
6506 }
6507 match map.next_value::<DeserializeWith>() {
6508 Ok(deserialize_with) => deserialize_with.0,
6509 Err(err) => {
6510 return Err(err);
6511 }
6512 }
6513 });
6514 }
6515 Field::Provider => {
6516 if r#provider_property.is_some() {
6517 return Err(<A::Error as de::Error>::duplicate_field(
6518 "provider",
6519 ));
6520 }
6521 r#provider_property = Some({
6522 struct DeserializeWith(Vec<ProviderProperty>);
6523 impl<'de> Deserialize<'de> for DeserializeWith {
6524 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6525 where
6526 D: Deserializer<'de>,
6527 {
6528 Ok(DeserializeWith(serde_with::As::<
6529 serde_with::OneOrMany<serde_with::Same>,
6530 >::deserialize(deserializer)?))
6531 }
6532 }
6533 match map.next_value::<DeserializeWith>() {
6534 Ok(deserialize_with) => deserialize_with.0,
6535 Err(err) => {
6536 return Err(err);
6537 }
6538 }
6539 });
6540 }
6541 Field::Publication => {
6542 if r#publication_property.is_some() {
6543 return Err(<A::Error as de::Error>::duplicate_field(
6544 "publication",
6545 ));
6546 }
6547 r#publication_property = Some({
6548 struct DeserializeWith(Vec<PublicationProperty>);
6549 impl<'de> Deserialize<'de> for DeserializeWith {
6550 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6551 where
6552 D: Deserializer<'de>,
6553 {
6554 Ok(DeserializeWith(serde_with::As::<
6555 serde_with::OneOrMany<serde_with::Same>,
6556 >::deserialize(deserializer)?))
6557 }
6558 }
6559 match map.next_value::<DeserializeWith>() {
6560 Ok(deserialize_with) => deserialize_with.0,
6561 Err(err) => {
6562 return Err(err);
6563 }
6564 }
6565 });
6566 }
6567 Field::Publisher => {
6568 if r#publisher_property.is_some() {
6569 return Err(<A::Error as de::Error>::duplicate_field(
6570 "publisher",
6571 ));
6572 }
6573 r#publisher_property = Some({
6574 struct DeserializeWith(Vec<PublisherProperty>);
6575 impl<'de> Deserialize<'de> for DeserializeWith {
6576 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6577 where
6578 D: Deserializer<'de>,
6579 {
6580 Ok(DeserializeWith(serde_with::As::<
6581 serde_with::OneOrMany<serde_with::Same>,
6582 >::deserialize(deserializer)?))
6583 }
6584 }
6585 match map.next_value::<DeserializeWith>() {
6586 Ok(deserialize_with) => deserialize_with.0,
6587 Err(err) => {
6588 return Err(err);
6589 }
6590 }
6591 });
6592 }
6593 Field::PublisherImprint => {
6594 if r#publisher_imprint_property.is_some() {
6595 return Err(<A::Error as de::Error>::duplicate_field(
6596 "publisherImprint",
6597 ));
6598 }
6599 r#publisher_imprint_property = Some({
6600 struct DeserializeWith(Vec<PublisherImprintProperty>);
6601 impl<'de> Deserialize<'de> for DeserializeWith {
6602 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6603 where
6604 D: Deserializer<'de>,
6605 {
6606 Ok(DeserializeWith(serde_with::As::<
6607 serde_with::OneOrMany<serde_with::Same>,
6608 >::deserialize(deserializer)?))
6609 }
6610 }
6611 match map.next_value::<DeserializeWith>() {
6612 Ok(deserialize_with) => deserialize_with.0,
6613 Err(err) => {
6614 return Err(err);
6615 }
6616 }
6617 });
6618 }
6619 Field::PublishingPrinciples => {
6620 if r#publishing_principles_property.is_some() {
6621 return Err(<A::Error as de::Error>::duplicate_field(
6622 "publishingPrinciples",
6623 ));
6624 }
6625 r#publishing_principles_property = Some({
6626 struct DeserializeWith(Vec<PublishingPrinciplesProperty>);
6627 impl<'de> Deserialize<'de> for DeserializeWith {
6628 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6629 where
6630 D: Deserializer<'de>,
6631 {
6632 Ok(DeserializeWith(serde_with::As::<
6633 serde_with::OneOrMany<serde_with::Same>,
6634 >::deserialize(deserializer)?))
6635 }
6636 }
6637 match map.next_value::<DeserializeWith>() {
6638 Ok(deserialize_with) => deserialize_with.0,
6639 Err(err) => {
6640 return Err(err);
6641 }
6642 }
6643 });
6644 }
6645 Field::RecordedAt => {
6646 if r#recorded_at_property.is_some() {
6647 return Err(<A::Error as de::Error>::duplicate_field(
6648 "recordedAt",
6649 ));
6650 }
6651 r#recorded_at_property = Some({
6652 struct DeserializeWith(Vec<RecordedAtProperty>);
6653 impl<'de> Deserialize<'de> for DeserializeWith {
6654 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6655 where
6656 D: Deserializer<'de>,
6657 {
6658 Ok(DeserializeWith(serde_with::As::<
6659 serde_with::OneOrMany<serde_with::Same>,
6660 >::deserialize(deserializer)?))
6661 }
6662 }
6663 match map.next_value::<DeserializeWith>() {
6664 Ok(deserialize_with) => deserialize_with.0,
6665 Err(err) => {
6666 return Err(err);
6667 }
6668 }
6669 });
6670 }
6671 Field::ReleasedEvent => {
6672 if r#released_event_property.is_some() {
6673 return Err(<A::Error as de::Error>::duplicate_field(
6674 "releasedEvent",
6675 ));
6676 }
6677 r#released_event_property = Some({
6678 struct DeserializeWith(Vec<ReleasedEventProperty>);
6679 impl<'de> Deserialize<'de> for DeserializeWith {
6680 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6681 where
6682 D: Deserializer<'de>,
6683 {
6684 Ok(DeserializeWith(serde_with::As::<
6685 serde_with::OneOrMany<serde_with::Same>,
6686 >::deserialize(deserializer)?))
6687 }
6688 }
6689 match map.next_value::<DeserializeWith>() {
6690 Ok(deserialize_with) => deserialize_with.0,
6691 Err(err) => {
6692 return Err(err);
6693 }
6694 }
6695 });
6696 }
6697 Field::Review => {
6698 if r#review_property.is_some() {
6699 return Err(<A::Error as de::Error>::duplicate_field("review"));
6700 }
6701 r#review_property = Some({
6702 struct DeserializeWith(Vec<ReviewProperty>);
6703 impl<'de> Deserialize<'de> for DeserializeWith {
6704 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6705 where
6706 D: Deserializer<'de>,
6707 {
6708 Ok(DeserializeWith(serde_with::As::<
6709 serde_with::OneOrMany<serde_with::Same>,
6710 >::deserialize(deserializer)?))
6711 }
6712 }
6713 match map.next_value::<DeserializeWith>() {
6714 Ok(deserialize_with) => deserialize_with.0,
6715 Err(err) => {
6716 return Err(err);
6717 }
6718 }
6719 });
6720 }
6721 Field::Reviews => {
6722 if r#reviews_property.is_some() {
6723 return Err(<A::Error as de::Error>::duplicate_field(
6724 "reviews",
6725 ));
6726 }
6727 r#reviews_property = Some({
6728 struct DeserializeWith(Vec<ReviewsProperty>);
6729 impl<'de> Deserialize<'de> for DeserializeWith {
6730 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6731 where
6732 D: Deserializer<'de>,
6733 {
6734 Ok(DeserializeWith(serde_with::As::<
6735 serde_with::OneOrMany<serde_with::Same>,
6736 >::deserialize(deserializer)?))
6737 }
6738 }
6739 match map.next_value::<DeserializeWith>() {
6740 Ok(deserialize_with) => deserialize_with.0,
6741 Err(err) => {
6742 return Err(err);
6743 }
6744 }
6745 });
6746 }
6747 Field::SchemaVersion => {
6748 if r#schema_version_property.is_some() {
6749 return Err(<A::Error as de::Error>::duplicate_field(
6750 "schemaVersion",
6751 ));
6752 }
6753 r#schema_version_property = Some({
6754 struct DeserializeWith(Vec<SchemaVersionProperty>);
6755 impl<'de> Deserialize<'de> for DeserializeWith {
6756 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6757 where
6758 D: Deserializer<'de>,
6759 {
6760 Ok(DeserializeWith(serde_with::As::<
6761 serde_with::OneOrMany<serde_with::Same>,
6762 >::deserialize(deserializer)?))
6763 }
6764 }
6765 match map.next_value::<DeserializeWith>() {
6766 Ok(deserialize_with) => deserialize_with.0,
6767 Err(err) => {
6768 return Err(err);
6769 }
6770 }
6771 });
6772 }
6773 Field::SdDatePublished => {
6774 if r#sd_date_published_property.is_some() {
6775 return Err(<A::Error as de::Error>::duplicate_field(
6776 "sdDatePublished",
6777 ));
6778 }
6779 r#sd_date_published_property = Some({
6780 struct DeserializeWith(Vec<SdDatePublishedProperty>);
6781 impl<'de> Deserialize<'de> for DeserializeWith {
6782 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6783 where
6784 D: Deserializer<'de>,
6785 {
6786 Ok(DeserializeWith(serde_with::As::<
6787 serde_with::OneOrMany<serde_with::Same>,
6788 >::deserialize(deserializer)?))
6789 }
6790 }
6791 match map.next_value::<DeserializeWith>() {
6792 Ok(deserialize_with) => deserialize_with.0,
6793 Err(err) => {
6794 return Err(err);
6795 }
6796 }
6797 });
6798 }
6799 Field::SdLicense => {
6800 if r#sd_license_property.is_some() {
6801 return Err(<A::Error as de::Error>::duplicate_field(
6802 "sdLicense",
6803 ));
6804 }
6805 r#sd_license_property = Some({
6806 struct DeserializeWith(Vec<SdLicenseProperty>);
6807 impl<'de> Deserialize<'de> for DeserializeWith {
6808 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6809 where
6810 D: Deserializer<'de>,
6811 {
6812 Ok(DeserializeWith(serde_with::As::<
6813 serde_with::OneOrMany<serde_with::Same>,
6814 >::deserialize(deserializer)?))
6815 }
6816 }
6817 match map.next_value::<DeserializeWith>() {
6818 Ok(deserialize_with) => deserialize_with.0,
6819 Err(err) => {
6820 return Err(err);
6821 }
6822 }
6823 });
6824 }
6825 Field::SdPublisher => {
6826 if r#sd_publisher_property.is_some() {
6827 return Err(<A::Error as de::Error>::duplicate_field(
6828 "sdPublisher",
6829 ));
6830 }
6831 r#sd_publisher_property = Some({
6832 struct DeserializeWith(Vec<SdPublisherProperty>);
6833 impl<'de> Deserialize<'de> for DeserializeWith {
6834 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6835 where
6836 D: Deserializer<'de>,
6837 {
6838 Ok(DeserializeWith(serde_with::As::<
6839 serde_with::OneOrMany<serde_with::Same>,
6840 >::deserialize(deserializer)?))
6841 }
6842 }
6843 match map.next_value::<DeserializeWith>() {
6844 Ok(deserialize_with) => deserialize_with.0,
6845 Err(err) => {
6846 return Err(err);
6847 }
6848 }
6849 });
6850 }
6851 Field::Size => {
6852 if r#size_property.is_some() {
6853 return Err(<A::Error as de::Error>::duplicate_field("size"));
6854 }
6855 r#size_property = Some({
6856 struct DeserializeWith(Vec<SizeProperty>);
6857 impl<'de> Deserialize<'de> for DeserializeWith {
6858 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6859 where
6860 D: Deserializer<'de>,
6861 {
6862 Ok(DeserializeWith(serde_with::As::<
6863 serde_with::OneOrMany<serde_with::Same>,
6864 >::deserialize(deserializer)?))
6865 }
6866 }
6867 match map.next_value::<DeserializeWith>() {
6868 Ok(deserialize_with) => deserialize_with.0,
6869 Err(err) => {
6870 return Err(err);
6871 }
6872 }
6873 });
6874 }
6875 Field::SourceOrganization => {
6876 if r#source_organization_property.is_some() {
6877 return Err(<A::Error as de::Error>::duplicate_field(
6878 "sourceOrganization",
6879 ));
6880 }
6881 r#source_organization_property = Some({
6882 struct DeserializeWith(Vec<SourceOrganizationProperty>);
6883 impl<'de> Deserialize<'de> for DeserializeWith {
6884 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6885 where
6886 D: Deserializer<'de>,
6887 {
6888 Ok(DeserializeWith(serde_with::As::<
6889 serde_with::OneOrMany<serde_with::Same>,
6890 >::deserialize(deserializer)?))
6891 }
6892 }
6893 match map.next_value::<DeserializeWith>() {
6894 Ok(deserialize_with) => deserialize_with.0,
6895 Err(err) => {
6896 return Err(err);
6897 }
6898 }
6899 });
6900 }
6901 Field::Spatial => {
6902 if r#spatial_property.is_some() {
6903 return Err(<A::Error as de::Error>::duplicate_field(
6904 "spatial",
6905 ));
6906 }
6907 r#spatial_property = Some({
6908 struct DeserializeWith(Vec<SpatialProperty>);
6909 impl<'de> Deserialize<'de> for DeserializeWith {
6910 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6911 where
6912 D: Deserializer<'de>,
6913 {
6914 Ok(DeserializeWith(serde_with::As::<
6915 serde_with::OneOrMany<serde_with::Same>,
6916 >::deserialize(deserializer)?))
6917 }
6918 }
6919 match map.next_value::<DeserializeWith>() {
6920 Ok(deserialize_with) => deserialize_with.0,
6921 Err(err) => {
6922 return Err(err);
6923 }
6924 }
6925 });
6926 }
6927 Field::SpatialCoverage => {
6928 if r#spatial_coverage_property.is_some() {
6929 return Err(<A::Error as de::Error>::duplicate_field(
6930 "spatialCoverage",
6931 ));
6932 }
6933 r#spatial_coverage_property = Some({
6934 struct DeserializeWith(Vec<SpatialCoverageProperty>);
6935 impl<'de> Deserialize<'de> for DeserializeWith {
6936 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6937 where
6938 D: Deserializer<'de>,
6939 {
6940 Ok(DeserializeWith(serde_with::As::<
6941 serde_with::OneOrMany<serde_with::Same>,
6942 >::deserialize(deserializer)?))
6943 }
6944 }
6945 match map.next_value::<DeserializeWith>() {
6946 Ok(deserialize_with) => deserialize_with.0,
6947 Err(err) => {
6948 return Err(err);
6949 }
6950 }
6951 });
6952 }
6953 Field::Sponsor => {
6954 if r#sponsor_property.is_some() {
6955 return Err(<A::Error as de::Error>::duplicate_field(
6956 "sponsor",
6957 ));
6958 }
6959 r#sponsor_property = Some({
6960 struct DeserializeWith(Vec<SponsorProperty>);
6961 impl<'de> Deserialize<'de> for DeserializeWith {
6962 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6963 where
6964 D: Deserializer<'de>,
6965 {
6966 Ok(DeserializeWith(serde_with::As::<
6967 serde_with::OneOrMany<serde_with::Same>,
6968 >::deserialize(deserializer)?))
6969 }
6970 }
6971 match map.next_value::<DeserializeWith>() {
6972 Ok(deserialize_with) => deserialize_with.0,
6973 Err(err) => {
6974 return Err(err);
6975 }
6976 }
6977 });
6978 }
6979 Field::Teaches => {
6980 if r#teaches_property.is_some() {
6981 return Err(<A::Error as de::Error>::duplicate_field(
6982 "teaches",
6983 ));
6984 }
6985 r#teaches_property = Some({
6986 struct DeserializeWith(Vec<TeachesProperty>);
6987 impl<'de> Deserialize<'de> for DeserializeWith {
6988 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
6989 where
6990 D: Deserializer<'de>,
6991 {
6992 Ok(DeserializeWith(serde_with::As::<
6993 serde_with::OneOrMany<serde_with::Same>,
6994 >::deserialize(deserializer)?))
6995 }
6996 }
6997 match map.next_value::<DeserializeWith>() {
6998 Ok(deserialize_with) => deserialize_with.0,
6999 Err(err) => {
7000 return Err(err);
7001 }
7002 }
7003 });
7004 }
7005 Field::Temporal => {
7006 if r#temporal_property.is_some() {
7007 return Err(<A::Error as de::Error>::duplicate_field(
7008 "temporal",
7009 ));
7010 }
7011 r#temporal_property = Some({
7012 struct DeserializeWith(Vec<TemporalProperty>);
7013 impl<'de> Deserialize<'de> for DeserializeWith {
7014 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7015 where
7016 D: Deserializer<'de>,
7017 {
7018 Ok(DeserializeWith(serde_with::As::<
7019 serde_with::OneOrMany<serde_with::Same>,
7020 >::deserialize(deserializer)?))
7021 }
7022 }
7023 match map.next_value::<DeserializeWith>() {
7024 Ok(deserialize_with) => deserialize_with.0,
7025 Err(err) => {
7026 return Err(err);
7027 }
7028 }
7029 });
7030 }
7031 Field::TemporalCoverage => {
7032 if r#temporal_coverage_property.is_some() {
7033 return Err(<A::Error as de::Error>::duplicate_field(
7034 "temporalCoverage",
7035 ));
7036 }
7037 r#temporal_coverage_property = Some({
7038 struct DeserializeWith(Vec<TemporalCoverageProperty>);
7039 impl<'de> Deserialize<'de> for DeserializeWith {
7040 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7041 where
7042 D: Deserializer<'de>,
7043 {
7044 Ok(DeserializeWith(serde_with::As::<
7045 serde_with::OneOrMany<serde_with::Same>,
7046 >::deserialize(deserializer)?))
7047 }
7048 }
7049 match map.next_value::<DeserializeWith>() {
7050 Ok(deserialize_with) => deserialize_with.0,
7051 Err(err) => {
7052 return Err(err);
7053 }
7054 }
7055 });
7056 }
7057 Field::Text => {
7058 if r#text_property.is_some() {
7059 return Err(<A::Error as de::Error>::duplicate_field("text"));
7060 }
7061 r#text_property = Some({
7062 struct DeserializeWith(Vec<TextProperty>);
7063 impl<'de> Deserialize<'de> for DeserializeWith {
7064 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7065 where
7066 D: Deserializer<'de>,
7067 {
7068 Ok(DeserializeWith(serde_with::As::<
7069 serde_with::OneOrMany<serde_with::Same>,
7070 >::deserialize(deserializer)?))
7071 }
7072 }
7073 match map.next_value::<DeserializeWith>() {
7074 Ok(deserialize_with) => deserialize_with.0,
7075 Err(err) => {
7076 return Err(err);
7077 }
7078 }
7079 });
7080 }
7081 Field::Thumbnail => {
7082 if r#thumbnail_property.is_some() {
7083 return Err(<A::Error as de::Error>::duplicate_field(
7084 "thumbnail",
7085 ));
7086 }
7087 r#thumbnail_property = Some({
7088 struct DeserializeWith(Vec<ThumbnailProperty>);
7089 impl<'de> Deserialize<'de> for DeserializeWith {
7090 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7091 where
7092 D: Deserializer<'de>,
7093 {
7094 Ok(DeserializeWith(serde_with::As::<
7095 serde_with::OneOrMany<serde_with::Same>,
7096 >::deserialize(deserializer)?))
7097 }
7098 }
7099 match map.next_value::<DeserializeWith>() {
7100 Ok(deserialize_with) => deserialize_with.0,
7101 Err(err) => {
7102 return Err(err);
7103 }
7104 }
7105 });
7106 }
7107 Field::ThumbnailUrl => {
7108 if r#thumbnail_url_property.is_some() {
7109 return Err(<A::Error as de::Error>::duplicate_field(
7110 "thumbnailUrl",
7111 ));
7112 }
7113 r#thumbnail_url_property = Some({
7114 struct DeserializeWith(Vec<ThumbnailUrlProperty>);
7115 impl<'de> Deserialize<'de> for DeserializeWith {
7116 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7117 where
7118 D: Deserializer<'de>,
7119 {
7120 Ok(DeserializeWith(serde_with::As::<
7121 serde_with::OneOrMany<serde_with::Same>,
7122 >::deserialize(deserializer)?))
7123 }
7124 }
7125 match map.next_value::<DeserializeWith>() {
7126 Ok(deserialize_with) => deserialize_with.0,
7127 Err(err) => {
7128 return Err(err);
7129 }
7130 }
7131 });
7132 }
7133 Field::TimeRequired => {
7134 if r#time_required_property.is_some() {
7135 return Err(<A::Error as de::Error>::duplicate_field(
7136 "timeRequired",
7137 ));
7138 }
7139 r#time_required_property = Some({
7140 struct DeserializeWith(Vec<TimeRequiredProperty>);
7141 impl<'de> Deserialize<'de> for DeserializeWith {
7142 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7143 where
7144 D: Deserializer<'de>,
7145 {
7146 Ok(DeserializeWith(serde_with::As::<
7147 serde_with::OneOrMany<serde_with::Same>,
7148 >::deserialize(deserializer)?))
7149 }
7150 }
7151 match map.next_value::<DeserializeWith>() {
7152 Ok(deserialize_with) => deserialize_with.0,
7153 Err(err) => {
7154 return Err(err);
7155 }
7156 }
7157 });
7158 }
7159 Field::TranslationOfWork => {
7160 if r#translation_of_work_property.is_some() {
7161 return Err(<A::Error as de::Error>::duplicate_field(
7162 "translationOfWork",
7163 ));
7164 }
7165 r#translation_of_work_property = Some({
7166 struct DeserializeWith(Vec<TranslationOfWorkProperty>);
7167 impl<'de> Deserialize<'de> for DeserializeWith {
7168 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7169 where
7170 D: Deserializer<'de>,
7171 {
7172 Ok(DeserializeWith(serde_with::As::<
7173 serde_with::OneOrMany<serde_with::Same>,
7174 >::deserialize(deserializer)?))
7175 }
7176 }
7177 match map.next_value::<DeserializeWith>() {
7178 Ok(deserialize_with) => deserialize_with.0,
7179 Err(err) => {
7180 return Err(err);
7181 }
7182 }
7183 });
7184 }
7185 Field::Translator => {
7186 if r#translator_property.is_some() {
7187 return Err(<A::Error as de::Error>::duplicate_field(
7188 "translator",
7189 ));
7190 }
7191 r#translator_property = Some({
7192 struct DeserializeWith(Vec<TranslatorProperty>);
7193 impl<'de> Deserialize<'de> for DeserializeWith {
7194 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7195 where
7196 D: Deserializer<'de>,
7197 {
7198 Ok(DeserializeWith(serde_with::As::<
7199 serde_with::OneOrMany<serde_with::Same>,
7200 >::deserialize(deserializer)?))
7201 }
7202 }
7203 match map.next_value::<DeserializeWith>() {
7204 Ok(deserialize_with) => deserialize_with.0,
7205 Err(err) => {
7206 return Err(err);
7207 }
7208 }
7209 });
7210 }
7211 Field::TypicalAgeRange => {
7212 if r#typical_age_range_property.is_some() {
7213 return Err(<A::Error as de::Error>::duplicate_field(
7214 "typicalAgeRange",
7215 ));
7216 }
7217 r#typical_age_range_property = Some({
7218 struct DeserializeWith(Vec<TypicalAgeRangeProperty>);
7219 impl<'de> Deserialize<'de> for DeserializeWith {
7220 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7221 where
7222 D: Deserializer<'de>,
7223 {
7224 Ok(DeserializeWith(serde_with::As::<
7225 serde_with::OneOrMany<serde_with::Same>,
7226 >::deserialize(deserializer)?))
7227 }
7228 }
7229 match map.next_value::<DeserializeWith>() {
7230 Ok(deserialize_with) => deserialize_with.0,
7231 Err(err) => {
7232 return Err(err);
7233 }
7234 }
7235 });
7236 }
7237 Field::UsageInfo => {
7238 if r#usage_info_property.is_some() {
7239 return Err(<A::Error as de::Error>::duplicate_field(
7240 "usageInfo",
7241 ));
7242 }
7243 r#usage_info_property = Some({
7244 struct DeserializeWith(Vec<UsageInfoProperty>);
7245 impl<'de> Deserialize<'de> for DeserializeWith {
7246 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7247 where
7248 D: Deserializer<'de>,
7249 {
7250 Ok(DeserializeWith(serde_with::As::<
7251 serde_with::OneOrMany<serde_with::Same>,
7252 >::deserialize(deserializer)?))
7253 }
7254 }
7255 match map.next_value::<DeserializeWith>() {
7256 Ok(deserialize_with) => deserialize_with.0,
7257 Err(err) => {
7258 return Err(err);
7259 }
7260 }
7261 });
7262 }
7263 Field::Version => {
7264 if r#version_property.is_some() {
7265 return Err(<A::Error as de::Error>::duplicate_field(
7266 "version",
7267 ));
7268 }
7269 r#version_property = Some({
7270 struct DeserializeWith(Vec<VersionProperty>);
7271 impl<'de> Deserialize<'de> for DeserializeWith {
7272 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7273 where
7274 D: Deserializer<'de>,
7275 {
7276 Ok(DeserializeWith(serde_with::As::<
7277 serde_with::OneOrMany<serde_with::Same>,
7278 >::deserialize(deserializer)?))
7279 }
7280 }
7281 match map.next_value::<DeserializeWith>() {
7282 Ok(deserialize_with) => deserialize_with.0,
7283 Err(err) => {
7284 return Err(err);
7285 }
7286 }
7287 });
7288 }
7289 Field::Video => {
7290 if r#video_property.is_some() {
7291 return Err(<A::Error as de::Error>::duplicate_field("video"));
7292 }
7293 r#video_property = Some({
7294 struct DeserializeWith(Vec<VideoProperty>);
7295 impl<'de> Deserialize<'de> for DeserializeWith {
7296 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7297 where
7298 D: Deserializer<'de>,
7299 {
7300 Ok(DeserializeWith(serde_with::As::<
7301 serde_with::OneOrMany<serde_with::Same>,
7302 >::deserialize(deserializer)?))
7303 }
7304 }
7305 match map.next_value::<DeserializeWith>() {
7306 Ok(deserialize_with) => deserialize_with.0,
7307 Err(err) => {
7308 return Err(err);
7309 }
7310 }
7311 });
7312 }
7313 Field::WorkExample => {
7314 if r#work_example_property.is_some() {
7315 return Err(<A::Error as de::Error>::duplicate_field(
7316 "workExample",
7317 ));
7318 }
7319 r#work_example_property = Some({
7320 struct DeserializeWith(Vec<WorkExampleProperty>);
7321 impl<'de> Deserialize<'de> for DeserializeWith {
7322 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7323 where
7324 D: Deserializer<'de>,
7325 {
7326 Ok(DeserializeWith(serde_with::As::<
7327 serde_with::OneOrMany<serde_with::Same>,
7328 >::deserialize(deserializer)?))
7329 }
7330 }
7331 match map.next_value::<DeserializeWith>() {
7332 Ok(deserialize_with) => deserialize_with.0,
7333 Err(err) => {
7334 return Err(err);
7335 }
7336 }
7337 });
7338 }
7339 Field::WorkTranslation => {
7340 if r#work_translation_property.is_some() {
7341 return Err(<A::Error as de::Error>::duplicate_field(
7342 "workTranslation",
7343 ));
7344 }
7345 r#work_translation_property = Some({
7346 struct DeserializeWith(Vec<WorkTranslationProperty>);
7347 impl<'de> Deserialize<'de> for DeserializeWith {
7348 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7349 where
7350 D: Deserializer<'de>,
7351 {
7352 Ok(DeserializeWith(serde_with::As::<
7353 serde_with::OneOrMany<serde_with::Same>,
7354 >::deserialize(deserializer)?))
7355 }
7356 }
7357 match map.next_value::<DeserializeWith>() {
7358 Ok(deserialize_with) => deserialize_with.0,
7359 Err(err) => {
7360 return Err(err);
7361 }
7362 }
7363 });
7364 }
7365 Field::Actor => {
7366 if r#actor_property.is_some() {
7367 return Err(<A::Error as de::Error>::duplicate_field("actor"));
7368 }
7369 r#actor_property = Some({
7370 struct DeserializeWith(Vec<ActorProperty>);
7371 impl<'de> Deserialize<'de> for DeserializeWith {
7372 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7373 where
7374 D: Deserializer<'de>,
7375 {
7376 Ok(DeserializeWith(serde_with::As::<
7377 serde_with::OneOrMany<serde_with::Same>,
7378 >::deserialize(deserializer)?))
7379 }
7380 }
7381 match map.next_value::<DeserializeWith>() {
7382 Ok(deserialize_with) => deserialize_with.0,
7383 Err(err) => {
7384 return Err(err);
7385 }
7386 }
7387 });
7388 }
7389 Field::Director => {
7390 if r#director_property.is_some() {
7391 return Err(<A::Error as de::Error>::duplicate_field(
7392 "director",
7393 ));
7394 }
7395 r#director_property = Some({
7396 struct DeserializeWith(Vec<DirectorProperty>);
7397 impl<'de> Deserialize<'de> for DeserializeWith {
7398 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7399 where
7400 D: Deserializer<'de>,
7401 {
7402 Ok(DeserializeWith(serde_with::As::<
7403 serde_with::OneOrMany<serde_with::Same>,
7404 >::deserialize(deserializer)?))
7405 }
7406 }
7407 match map.next_value::<DeserializeWith>() {
7408 Ok(deserialize_with) => deserialize_with.0,
7409 Err(err) => {
7410 return Err(err);
7411 }
7412 }
7413 });
7414 }
7415 Field::EndDate => {
7416 if r#end_date_property.is_some() {
7417 return Err(<A::Error as de::Error>::duplicate_field(
7418 "endDate",
7419 ));
7420 }
7421 r#end_date_property = Some({
7422 struct DeserializeWith(Vec<EndDateProperty>);
7423 impl<'de> Deserialize<'de> for DeserializeWith {
7424 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7425 where
7426 D: Deserializer<'de>,
7427 {
7428 Ok(DeserializeWith(serde_with::As::<
7429 serde_with::OneOrMany<serde_with::Same>,
7430 >::deserialize(deserializer)?))
7431 }
7432 }
7433 match map.next_value::<DeserializeWith>() {
7434 Ok(deserialize_with) => deserialize_with.0,
7435 Err(err) => {
7436 return Err(err);
7437 }
7438 }
7439 });
7440 }
7441 Field::Episode => {
7442 if r#episode_property.is_some() {
7443 return Err(<A::Error as de::Error>::duplicate_field(
7444 "episode",
7445 ));
7446 }
7447 r#episode_property = Some({
7448 struct DeserializeWith(Vec<EpisodeProperty>);
7449 impl<'de> Deserialize<'de> for DeserializeWith {
7450 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7451 where
7452 D: Deserializer<'de>,
7453 {
7454 Ok(DeserializeWith(serde_with::As::<
7455 serde_with::OneOrMany<serde_with::Same>,
7456 >::deserialize(deserializer)?))
7457 }
7458 }
7459 match map.next_value::<DeserializeWith>() {
7460 Ok(deserialize_with) => deserialize_with.0,
7461 Err(err) => {
7462 return Err(err);
7463 }
7464 }
7465 });
7466 }
7467 Field::Episodes => {
7468 if r#episodes_property.is_some() {
7469 return Err(<A::Error as de::Error>::duplicate_field(
7470 "episodes",
7471 ));
7472 }
7473 r#episodes_property = Some({
7474 struct DeserializeWith(Vec<EpisodesProperty>);
7475 impl<'de> Deserialize<'de> for DeserializeWith {
7476 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7477 where
7478 D: Deserializer<'de>,
7479 {
7480 Ok(DeserializeWith(serde_with::As::<
7481 serde_with::OneOrMany<serde_with::Same>,
7482 >::deserialize(deserializer)?))
7483 }
7484 }
7485 match map.next_value::<DeserializeWith>() {
7486 Ok(deserialize_with) => deserialize_with.0,
7487 Err(err) => {
7488 return Err(err);
7489 }
7490 }
7491 });
7492 }
7493 Field::NumberOfEpisodes => {
7494 if r#number_of_episodes_property.is_some() {
7495 return Err(<A::Error as de::Error>::duplicate_field(
7496 "numberOfEpisodes",
7497 ));
7498 }
7499 r#number_of_episodes_property = Some({
7500 struct DeserializeWith(Vec<NumberOfEpisodesProperty>);
7501 impl<'de> Deserialize<'de> for DeserializeWith {
7502 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7503 where
7504 D: Deserializer<'de>,
7505 {
7506 Ok(DeserializeWith(serde_with::As::<
7507 serde_with::OneOrMany<serde_with::Same>,
7508 >::deserialize(deserializer)?))
7509 }
7510 }
7511 match map.next_value::<DeserializeWith>() {
7512 Ok(deserialize_with) => deserialize_with.0,
7513 Err(err) => {
7514 return Err(err);
7515 }
7516 }
7517 });
7518 }
7519 Field::PartOfSeries => {
7520 if r#part_of_series_property.is_some() {
7521 return Err(<A::Error as de::Error>::duplicate_field(
7522 "partOfSeries",
7523 ));
7524 }
7525 r#part_of_series_property = Some({
7526 struct DeserializeWith(Vec<PartOfSeriesProperty>);
7527 impl<'de> Deserialize<'de> for DeserializeWith {
7528 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7529 where
7530 D: Deserializer<'de>,
7531 {
7532 Ok(DeserializeWith(serde_with::As::<
7533 serde_with::OneOrMany<serde_with::Same>,
7534 >::deserialize(deserializer)?))
7535 }
7536 }
7537 match map.next_value::<DeserializeWith>() {
7538 Ok(deserialize_with) => deserialize_with.0,
7539 Err(err) => {
7540 return Err(err);
7541 }
7542 }
7543 });
7544 }
7545 Field::ProductionCompany => {
7546 if r#production_company_property.is_some() {
7547 return Err(<A::Error as de::Error>::duplicate_field(
7548 "productionCompany",
7549 ));
7550 }
7551 r#production_company_property = Some({
7552 struct DeserializeWith(Vec<ProductionCompanyProperty>);
7553 impl<'de> Deserialize<'de> for DeserializeWith {
7554 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7555 where
7556 D: Deserializer<'de>,
7557 {
7558 Ok(DeserializeWith(serde_with::As::<
7559 serde_with::OneOrMany<serde_with::Same>,
7560 >::deserialize(deserializer)?))
7561 }
7562 }
7563 match map.next_value::<DeserializeWith>() {
7564 Ok(deserialize_with) => deserialize_with.0,
7565 Err(err) => {
7566 return Err(err);
7567 }
7568 }
7569 });
7570 }
7571 Field::SeasonNumber => {
7572 if r#season_number_property.is_some() {
7573 return Err(<A::Error as de::Error>::duplicate_field(
7574 "seasonNumber",
7575 ));
7576 }
7577 r#season_number_property = Some({
7578 struct DeserializeWith(Vec<SeasonNumberProperty>);
7579 impl<'de> Deserialize<'de> for DeserializeWith {
7580 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7581 where
7582 D: Deserializer<'de>,
7583 {
7584 Ok(DeserializeWith(serde_with::As::<
7585 serde_with::OneOrMany<serde_with::Same>,
7586 >::deserialize(deserializer)?))
7587 }
7588 }
7589 match map.next_value::<DeserializeWith>() {
7590 Ok(deserialize_with) => deserialize_with.0,
7591 Err(err) => {
7592 return Err(err);
7593 }
7594 }
7595 });
7596 }
7597 Field::StartDate => {
7598 if r#start_date_property.is_some() {
7599 return Err(<A::Error as de::Error>::duplicate_field(
7600 "startDate",
7601 ));
7602 }
7603 r#start_date_property = Some({
7604 struct DeserializeWith(Vec<StartDateProperty>);
7605 impl<'de> Deserialize<'de> for DeserializeWith {
7606 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7607 where
7608 D: Deserializer<'de>,
7609 {
7610 Ok(DeserializeWith(serde_with::As::<
7611 serde_with::OneOrMany<serde_with::Same>,
7612 >::deserialize(deserializer)?))
7613 }
7614 }
7615 match map.next_value::<DeserializeWith>() {
7616 Ok(deserialize_with) => deserialize_with.0,
7617 Err(err) => {
7618 return Err(err);
7619 }
7620 }
7621 });
7622 }
7623 Field::Trailer => {
7624 if r#trailer_property.is_some() {
7625 return Err(<A::Error as de::Error>::duplicate_field(
7626 "trailer",
7627 ));
7628 }
7629 r#trailer_property = Some({
7630 struct DeserializeWith(Vec<TrailerProperty>);
7631 impl<'de> Deserialize<'de> for DeserializeWith {
7632 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7633 where
7634 D: Deserializer<'de>,
7635 {
7636 Ok(DeserializeWith(serde_with::As::<
7637 serde_with::OneOrMany<serde_with::Same>,
7638 >::deserialize(deserializer)?))
7639 }
7640 }
7641 match map.next_value::<DeserializeWith>() {
7642 Ok(deserialize_with) => deserialize_with.0,
7643 Err(err) => {
7644 return Err(err);
7645 }
7646 }
7647 });
7648 }
7649 Field::AdditionalType => {
7650 if r#additional_type_property.is_some() {
7651 return Err(<A::Error as de::Error>::duplicate_field(
7652 "additionalType",
7653 ));
7654 }
7655 r#additional_type_property = Some({
7656 struct DeserializeWith(Vec<AdditionalTypeProperty>);
7657 impl<'de> Deserialize<'de> for DeserializeWith {
7658 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7659 where
7660 D: Deserializer<'de>,
7661 {
7662 Ok(DeserializeWith(serde_with::As::<
7663 serde_with::OneOrMany<serde_with::Same>,
7664 >::deserialize(deserializer)?))
7665 }
7666 }
7667 match map.next_value::<DeserializeWith>() {
7668 Ok(deserialize_with) => deserialize_with.0,
7669 Err(err) => {
7670 return Err(err);
7671 }
7672 }
7673 });
7674 }
7675 Field::AlternateName => {
7676 if r#alternate_name_property.is_some() {
7677 return Err(<A::Error as de::Error>::duplicate_field(
7678 "alternateName",
7679 ));
7680 }
7681 r#alternate_name_property = Some({
7682 struct DeserializeWith(Vec<AlternateNameProperty>);
7683 impl<'de> Deserialize<'de> for DeserializeWith {
7684 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7685 where
7686 D: Deserializer<'de>,
7687 {
7688 Ok(DeserializeWith(serde_with::As::<
7689 serde_with::OneOrMany<serde_with::Same>,
7690 >::deserialize(deserializer)?))
7691 }
7692 }
7693 match map.next_value::<DeserializeWith>() {
7694 Ok(deserialize_with) => deserialize_with.0,
7695 Err(err) => {
7696 return Err(err);
7697 }
7698 }
7699 });
7700 }
7701 Field::Description => {
7702 if r#description_property.is_some() {
7703 return Err(<A::Error as de::Error>::duplicate_field(
7704 "description",
7705 ));
7706 }
7707 r#description_property = Some({
7708 struct DeserializeWith(Vec<DescriptionProperty>);
7709 impl<'de> Deserialize<'de> for DeserializeWith {
7710 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7711 where
7712 D: Deserializer<'de>,
7713 {
7714 Ok(DeserializeWith(serde_with::As::<
7715 serde_with::OneOrMany<serde_with::Same>,
7716 >::deserialize(deserializer)?))
7717 }
7718 }
7719 match map.next_value::<DeserializeWith>() {
7720 Ok(deserialize_with) => deserialize_with.0,
7721 Err(err) => {
7722 return Err(err);
7723 }
7724 }
7725 });
7726 }
7727 Field::DisambiguatingDescription => {
7728 if r#disambiguating_description_property.is_some() {
7729 return Err(<A::Error as de::Error>::duplicate_field(
7730 "disambiguatingDescription",
7731 ));
7732 }
7733 r#disambiguating_description_property = Some({
7734 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
7735 impl<'de> Deserialize<'de> for DeserializeWith {
7736 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7737 where
7738 D: Deserializer<'de>,
7739 {
7740 Ok(DeserializeWith(serde_with::As::<
7741 serde_with::OneOrMany<serde_with::Same>,
7742 >::deserialize(deserializer)?))
7743 }
7744 }
7745 match map.next_value::<DeserializeWith>() {
7746 Ok(deserialize_with) => deserialize_with.0,
7747 Err(err) => {
7748 return Err(err);
7749 }
7750 }
7751 });
7752 }
7753 Field::Identifier => {
7754 if r#identifier_property.is_some() {
7755 return Err(<A::Error as de::Error>::duplicate_field(
7756 "identifier",
7757 ));
7758 }
7759 r#identifier_property = Some({
7760 struct DeserializeWith(Vec<IdentifierProperty>);
7761 impl<'de> Deserialize<'de> for DeserializeWith {
7762 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7763 where
7764 D: Deserializer<'de>,
7765 {
7766 Ok(DeserializeWith(serde_with::As::<
7767 serde_with::OneOrMany<serde_with::Same>,
7768 >::deserialize(deserializer)?))
7769 }
7770 }
7771 match map.next_value::<DeserializeWith>() {
7772 Ok(deserialize_with) => deserialize_with.0,
7773 Err(err) => {
7774 return Err(err);
7775 }
7776 }
7777 });
7778 }
7779 Field::Image => {
7780 if r#image_property.is_some() {
7781 return Err(<A::Error as de::Error>::duplicate_field("image"));
7782 }
7783 r#image_property = Some({
7784 struct DeserializeWith(Vec<ImageProperty>);
7785 impl<'de> Deserialize<'de> for DeserializeWith {
7786 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7787 where
7788 D: Deserializer<'de>,
7789 {
7790 Ok(DeserializeWith(serde_with::As::<
7791 serde_with::OneOrMany<serde_with::Same>,
7792 >::deserialize(deserializer)?))
7793 }
7794 }
7795 match map.next_value::<DeserializeWith>() {
7796 Ok(deserialize_with) => deserialize_with.0,
7797 Err(err) => {
7798 return Err(err);
7799 }
7800 }
7801 });
7802 }
7803 Field::MainEntityOfPage => {
7804 if r#main_entity_of_page_property.is_some() {
7805 return Err(<A::Error as de::Error>::duplicate_field(
7806 "mainEntityOfPage",
7807 ));
7808 }
7809 r#main_entity_of_page_property = Some({
7810 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
7811 impl<'de> Deserialize<'de> for DeserializeWith {
7812 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7813 where
7814 D: Deserializer<'de>,
7815 {
7816 Ok(DeserializeWith(serde_with::As::<
7817 serde_with::OneOrMany<serde_with::Same>,
7818 >::deserialize(deserializer)?))
7819 }
7820 }
7821 match map.next_value::<DeserializeWith>() {
7822 Ok(deserialize_with) => deserialize_with.0,
7823 Err(err) => {
7824 return Err(err);
7825 }
7826 }
7827 });
7828 }
7829 Field::Name => {
7830 if r#name_property.is_some() {
7831 return Err(<A::Error as de::Error>::duplicate_field("name"));
7832 }
7833 r#name_property = Some({
7834 struct DeserializeWith(Vec<NameProperty>);
7835 impl<'de> Deserialize<'de> for DeserializeWith {
7836 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7837 where
7838 D: Deserializer<'de>,
7839 {
7840 Ok(DeserializeWith(serde_with::As::<
7841 serde_with::OneOrMany<serde_with::Same>,
7842 >::deserialize(deserializer)?))
7843 }
7844 }
7845 match map.next_value::<DeserializeWith>() {
7846 Ok(deserialize_with) => deserialize_with.0,
7847 Err(err) => {
7848 return Err(err);
7849 }
7850 }
7851 });
7852 }
7853 Field::PotentialAction => {
7854 if r#potential_action_property.is_some() {
7855 return Err(<A::Error as de::Error>::duplicate_field(
7856 "potentialAction",
7857 ));
7858 }
7859 r#potential_action_property = Some({
7860 struct DeserializeWith(Vec<PotentialActionProperty>);
7861 impl<'de> Deserialize<'de> for DeserializeWith {
7862 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7863 where
7864 D: Deserializer<'de>,
7865 {
7866 Ok(DeserializeWith(serde_with::As::<
7867 serde_with::OneOrMany<serde_with::Same>,
7868 >::deserialize(deserializer)?))
7869 }
7870 }
7871 match map.next_value::<DeserializeWith>() {
7872 Ok(deserialize_with) => deserialize_with.0,
7873 Err(err) => {
7874 return Err(err);
7875 }
7876 }
7877 });
7878 }
7879 Field::SameAs => {
7880 if r#same_as_property.is_some() {
7881 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
7882 }
7883 r#same_as_property = Some({
7884 struct DeserializeWith(Vec<SameAsProperty>);
7885 impl<'de> Deserialize<'de> for DeserializeWith {
7886 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7887 where
7888 D: Deserializer<'de>,
7889 {
7890 Ok(DeserializeWith(serde_with::As::<
7891 serde_with::OneOrMany<serde_with::Same>,
7892 >::deserialize(deserializer)?))
7893 }
7894 }
7895 match map.next_value::<DeserializeWith>() {
7896 Ok(deserialize_with) => deserialize_with.0,
7897 Err(err) => {
7898 return Err(err);
7899 }
7900 }
7901 });
7902 }
7903 Field::SubjectOf => {
7904 if r#subject_of_property.is_some() {
7905 return Err(<A::Error as de::Error>::duplicate_field(
7906 "subjectOf",
7907 ));
7908 }
7909 r#subject_of_property = Some({
7910 struct DeserializeWith(Vec<SubjectOfProperty>);
7911 impl<'de> Deserialize<'de> for DeserializeWith {
7912 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7913 where
7914 D: Deserializer<'de>,
7915 {
7916 Ok(DeserializeWith(serde_with::As::<
7917 serde_with::OneOrMany<serde_with::Same>,
7918 >::deserialize(deserializer)?))
7919 }
7920 }
7921 match map.next_value::<DeserializeWith>() {
7922 Ok(deserialize_with) => deserialize_with.0,
7923 Err(err) => {
7924 return Err(err);
7925 }
7926 }
7927 });
7928 }
7929 Field::Url => {
7930 if r#url_property.is_some() {
7931 return Err(<A::Error as de::Error>::duplicate_field("url"));
7932 }
7933 r#url_property = Some({
7934 struct DeserializeWith(Vec<UrlProperty>);
7935 impl<'de> Deserialize<'de> for DeserializeWith {
7936 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7937 where
7938 D: Deserializer<'de>,
7939 {
7940 Ok(DeserializeWith(serde_with::As::<
7941 serde_with::OneOrMany<serde_with::Same>,
7942 >::deserialize(deserializer)?))
7943 }
7944 }
7945 match map.next_value::<DeserializeWith>() {
7946 Ok(deserialize_with) => deserialize_with.0,
7947 Err(err) => {
7948 return Err(err);
7949 }
7950 }
7951 });
7952 }
7953 Field::Ignore => {
7954 let _ = map.next_value::<de::IgnoredAny>()?;
7955 }
7956 }
7957 }
7958 Ok(TvSeason {
7959 r#country_of_origin: r#country_of_origin_property.unwrap_or_default(),
7960 r#part_of_tv_series: r#part_of_tv_series_property.unwrap_or_default(),
7961 r#title_eidr: r#title_eidr_property.unwrap_or_default(),
7962 r#about: r#about_property.unwrap_or_default(),
7963 r#abstract: r#abstract_property.unwrap_or_default(),
7964 r#access_mode: r#access_mode_property.unwrap_or_default(),
7965 r#access_mode_sufficient: r#access_mode_sufficient_property
7966 .unwrap_or_default(),
7967 r#accessibility_api: r#accessibility_api_property.unwrap_or_default(),
7968 r#accessibility_control: r#accessibility_control_property
7969 .unwrap_or_default(),
7970 r#accessibility_feature: r#accessibility_feature_property
7971 .unwrap_or_default(),
7972 r#accessibility_hazard: r#accessibility_hazard_property.unwrap_or_default(),
7973 r#accessibility_summary: r#accessibility_summary_property
7974 .unwrap_or_default(),
7975 r#accountable_person: r#accountable_person_property.unwrap_or_default(),
7976 r#acquire_license_page: r#acquire_license_page_property.unwrap_or_default(),
7977 r#aggregate_rating: r#aggregate_rating_property.unwrap_or_default(),
7978 r#alternative_headline: r#alternative_headline_property.unwrap_or_default(),
7979 r#archived_at: r#archived_at_property.unwrap_or_default(),
7980 r#assesses: r#assesses_property.unwrap_or_default(),
7981 r#associated_media: r#associated_media_property.unwrap_or_default(),
7982 r#audience: r#audience_property.unwrap_or_default(),
7983 r#audio: r#audio_property.unwrap_or_default(),
7984 r#author: r#author_property.unwrap_or_default(),
7985 r#award: r#award_property.unwrap_or_default(),
7986 r#awards: r#awards_property.unwrap_or_default(),
7987 r#character: r#character_property.unwrap_or_default(),
7988 r#citation: r#citation_property.unwrap_or_default(),
7989 r#comment: r#comment_property.unwrap_or_default(),
7990 r#comment_count: r#comment_count_property.unwrap_or_default(),
7991 r#conditions_of_access: r#conditions_of_access_property.unwrap_or_default(),
7992 r#content_location: r#content_location_property.unwrap_or_default(),
7993 r#content_rating: r#content_rating_property.unwrap_or_default(),
7994 r#content_reference_time: r#content_reference_time_property
7995 .unwrap_or_default(),
7996 r#contributor: r#contributor_property.unwrap_or_default(),
7997 r#copyright_holder: r#copyright_holder_property.unwrap_or_default(),
7998 r#copyright_notice: r#copyright_notice_property.unwrap_or_default(),
7999 r#copyright_year: r#copyright_year_property.unwrap_or_default(),
8000 r#correction: r#correction_property.unwrap_or_default(),
8001 r#creative_work_status: r#creative_work_status_property.unwrap_or_default(),
8002 r#creator: r#creator_property.unwrap_or_default(),
8003 r#credit_text: r#credit_text_property.unwrap_or_default(),
8004 r#date_created: r#date_created_property.unwrap_or_default(),
8005 r#date_modified: r#date_modified_property.unwrap_or_default(),
8006 r#date_published: r#date_published_property.unwrap_or_default(),
8007 r#discussion_url: r#discussion_url_property.unwrap_or_default(),
8008 r#edit_eidr: r#edit_eidr_property.unwrap_or_default(),
8009 r#editor: r#editor_property.unwrap_or_default(),
8010 r#educational_alignment: r#educational_alignment_property
8011 .unwrap_or_default(),
8012 r#educational_level: r#educational_level_property.unwrap_or_default(),
8013 r#educational_use: r#educational_use_property.unwrap_or_default(),
8014 r#encoding: r#encoding_property.unwrap_or_default(),
8015 r#encoding_format: r#encoding_format_property.unwrap_or_default(),
8016 r#encodings: r#encodings_property.unwrap_or_default(),
8017 r#example_of_work: r#example_of_work_property.unwrap_or_default(),
8018 r#expires: r#expires_property.unwrap_or_default(),
8019 r#file_format: r#file_format_property.unwrap_or_default(),
8020 r#funder: r#funder_property.unwrap_or_default(),
8021 r#funding: r#funding_property.unwrap_or_default(),
8022 r#genre: r#genre_property.unwrap_or_default(),
8023 r#has_part: r#has_part_property.unwrap_or_default(),
8024 r#headline: r#headline_property.unwrap_or_default(),
8025 r#in_language: r#in_language_property.unwrap_or_default(),
8026 r#interaction_statistic: r#interaction_statistic_property
8027 .unwrap_or_default(),
8028 r#interactivity_type: r#interactivity_type_property.unwrap_or_default(),
8029 r#interpreted_as_claim: r#interpreted_as_claim_property.unwrap_or_default(),
8030 r#is_accessible_for_free: r#is_accessible_for_free_property
8031 .unwrap_or_default(),
8032 r#is_based_on: r#is_based_on_property.unwrap_or_default(),
8033 r#is_based_on_url: r#is_based_on_url_property.unwrap_or_default(),
8034 r#is_family_friendly: r#is_family_friendly_property.unwrap_or_default(),
8035 r#is_part_of: r#is_part_of_property.unwrap_or_default(),
8036 r#keywords: r#keywords_property.unwrap_or_default(),
8037 r#learning_resource_type: r#learning_resource_type_property
8038 .unwrap_or_default(),
8039 r#license: r#license_property.unwrap_or_default(),
8040 r#location_created: r#location_created_property.unwrap_or_default(),
8041 r#main_entity: r#main_entity_property.unwrap_or_default(),
8042 r#maintainer: r#maintainer_property.unwrap_or_default(),
8043 r#material: r#material_property.unwrap_or_default(),
8044 r#material_extent: r#material_extent_property.unwrap_or_default(),
8045 r#mentions: r#mentions_property.unwrap_or_default(),
8046 r#offers: r#offers_property.unwrap_or_default(),
8047 r#pattern: r#pattern_property.unwrap_or_default(),
8048 r#position: r#position_property.unwrap_or_default(),
8049 r#producer: r#producer_property.unwrap_or_default(),
8050 r#provider: r#provider_property.unwrap_or_default(),
8051 r#publication: r#publication_property.unwrap_or_default(),
8052 r#publisher: r#publisher_property.unwrap_or_default(),
8053 r#publisher_imprint: r#publisher_imprint_property.unwrap_or_default(),
8054 r#publishing_principles: r#publishing_principles_property
8055 .unwrap_or_default(),
8056 r#recorded_at: r#recorded_at_property.unwrap_or_default(),
8057 r#released_event: r#released_event_property.unwrap_or_default(),
8058 r#review: r#review_property.unwrap_or_default(),
8059 r#reviews: r#reviews_property.unwrap_or_default(),
8060 r#schema_version: r#schema_version_property.unwrap_or_default(),
8061 r#sd_date_published: r#sd_date_published_property.unwrap_or_default(),
8062 r#sd_license: r#sd_license_property.unwrap_or_default(),
8063 r#sd_publisher: r#sd_publisher_property.unwrap_or_default(),
8064 r#size: r#size_property.unwrap_or_default(),
8065 r#source_organization: r#source_organization_property.unwrap_or_default(),
8066 r#spatial: r#spatial_property.unwrap_or_default(),
8067 r#spatial_coverage: r#spatial_coverage_property.unwrap_or_default(),
8068 r#sponsor: r#sponsor_property.unwrap_or_default(),
8069 r#teaches: r#teaches_property.unwrap_or_default(),
8070 r#temporal: r#temporal_property.unwrap_or_default(),
8071 r#temporal_coverage: r#temporal_coverage_property.unwrap_or_default(),
8072 r#text: r#text_property.unwrap_or_default(),
8073 r#thumbnail: r#thumbnail_property.unwrap_or_default(),
8074 r#thumbnail_url: r#thumbnail_url_property.unwrap_or_default(),
8075 r#time_required: r#time_required_property.unwrap_or_default(),
8076 r#translation_of_work: r#translation_of_work_property.unwrap_or_default(),
8077 r#translator: r#translator_property.unwrap_or_default(),
8078 r#typical_age_range: r#typical_age_range_property.unwrap_or_default(),
8079 r#usage_info: r#usage_info_property.unwrap_or_default(),
8080 r#version: r#version_property.unwrap_or_default(),
8081 r#video: r#video_property.unwrap_or_default(),
8082 r#work_example: r#work_example_property.unwrap_or_default(),
8083 r#work_translation: r#work_translation_property.unwrap_or_default(),
8084 r#actor: r#actor_property.unwrap_or_default(),
8085 r#director: r#director_property.unwrap_or_default(),
8086 r#end_date: r#end_date_property.unwrap_or_default(),
8087 r#episode: r#episode_property.unwrap_or_default(),
8088 r#episodes: r#episodes_property.unwrap_or_default(),
8089 r#number_of_episodes: r#number_of_episodes_property.unwrap_or_default(),
8090 r#part_of_series: r#part_of_series_property.unwrap_or_default(),
8091 r#production_company: r#production_company_property.unwrap_or_default(),
8092 r#season_number: r#season_number_property.unwrap_or_default(),
8093 r#start_date: r#start_date_property.unwrap_or_default(),
8094 r#trailer: r#trailer_property.unwrap_or_default(),
8095 r#additional_type: r#additional_type_property.unwrap_or_default(),
8096 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
8097 r#description: r#description_property.unwrap_or_default(),
8098 r#disambiguating_description: r#disambiguating_description_property
8099 .unwrap_or_default(),
8100 r#identifier: r#identifier_property.unwrap_or_default(),
8101 r#image: r#image_property.unwrap_or_default(),
8102 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
8103 r#name: r#name_property.unwrap_or_default(),
8104 r#potential_action: r#potential_action_property.unwrap_or_default(),
8105 r#same_as: r#same_as_property.unwrap_or_default(),
8106 r#subject_of: r#subject_of_property.unwrap_or_default(),
8107 r#url: r#url_property.unwrap_or_default(),
8108 })
8109 }
8110 }
8111 const FIELDS: &[&str] = &[
8112 "countryOfOrigin",
8113 "partOfTVSeries",
8114 "titleEIDR",
8115 "about",
8116 "abstract",
8117 "accessMode",
8118 "accessModeSufficient",
8119 "accessibilityAPI",
8120 "accessibilityControl",
8121 "accessibilityFeature",
8122 "accessibilityHazard",
8123 "accessibilitySummary",
8124 "accountablePerson",
8125 "acquireLicensePage",
8126 "aggregateRating",
8127 "alternativeHeadline",
8128 "archivedAt",
8129 "assesses",
8130 "associatedMedia",
8131 "audience",
8132 "audio",
8133 "author",
8134 "award",
8135 "awards",
8136 "character",
8137 "citation",
8138 "comment",
8139 "commentCount",
8140 "conditionsOfAccess",
8141 "contentLocation",
8142 "contentRating",
8143 "contentReferenceTime",
8144 "contributor",
8145 "copyrightHolder",
8146 "copyrightNotice",
8147 "copyrightYear",
8148 "correction",
8149 "creativeWorkStatus",
8150 "creator",
8151 "creditText",
8152 "dateCreated",
8153 "dateModified",
8154 "datePublished",
8155 "discussionUrl",
8156 "editEIDR",
8157 "editor",
8158 "educationalAlignment",
8159 "educationalLevel",
8160 "educationalUse",
8161 "encoding",
8162 "encodingFormat",
8163 "encodings",
8164 "exampleOfWork",
8165 "expires",
8166 "fileFormat",
8167 "funder",
8168 "funding",
8169 "genre",
8170 "hasPart",
8171 "headline",
8172 "inLanguage",
8173 "interactionStatistic",
8174 "interactivityType",
8175 "interpretedAsClaim",
8176 "isAccessibleForFree",
8177 "isBasedOn",
8178 "isBasedOnUrl",
8179 "isFamilyFriendly",
8180 "isPartOf",
8181 "keywords",
8182 "learningResourceType",
8183 "license",
8184 "locationCreated",
8185 "mainEntity",
8186 "maintainer",
8187 "material",
8188 "materialExtent",
8189 "mentions",
8190 "offers",
8191 "pattern",
8192 "position",
8193 "producer",
8194 "provider",
8195 "publication",
8196 "publisher",
8197 "publisherImprint",
8198 "publishingPrinciples",
8199 "recordedAt",
8200 "releasedEvent",
8201 "review",
8202 "reviews",
8203 "schemaVersion",
8204 "sdDatePublished",
8205 "sdLicense",
8206 "sdPublisher",
8207 "size",
8208 "sourceOrganization",
8209 "spatial",
8210 "spatialCoverage",
8211 "sponsor",
8212 "teaches",
8213 "temporal",
8214 "temporalCoverage",
8215 "text",
8216 "thumbnail",
8217 "thumbnailUrl",
8218 "timeRequired",
8219 "translationOfWork",
8220 "translator",
8221 "typicalAgeRange",
8222 "usageInfo",
8223 "version",
8224 "video",
8225 "workExample",
8226 "workTranslation",
8227 "actor",
8228 "director",
8229 "endDate",
8230 "episode",
8231 "episodes",
8232 "numberOfEpisodes",
8233 "partOfSeries",
8234 "productionCompany",
8235 "seasonNumber",
8236 "startDate",
8237 "trailer",
8238 "additionalType",
8239 "alternateName",
8240 "description",
8241 "disambiguatingDescription",
8242 "identifier",
8243 "image",
8244 "mainEntityOfPage",
8245 "name",
8246 "potentialAction",
8247 "sameAs",
8248 "subjectOf",
8249 "url",
8250 ];
8251 deserializer.deserialize_struct("TvSeason", FIELDS, ClassVisitor)
8252 }
8253 }
8254}