content: // GENERATED CODE - DO NOT MODIFY BY HAND
  
  part of 'jikan_data.dart';
  
  // **************************************************************************
  // JsonSerializableGenerator
  // **************************************************************************
  
  JikanResp _$JikanRespFromJson(Map<String, dynamic> json) => JikanResp(
    (json['data'] as List<dynamic>)
        .map((e) => JKData.fromJson(e as Map<String, dynamic>))
        .toList(),
    pagination: json['pagination'] == null
        ? null
        : JKPagination.fromJson(json['pagination'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JikanRespToJson(JikanResp instance) => <String, dynamic>{
    'pagination': instance.pagination?.toJson(),
    'data': instance.data.map((e) => e.toJson()).toList(),
  };
  
  JKPagination _$JKPaginationFromJson(Map<String, dynamic> json) => JKPagination(
    (json['last_visible_page'] as num).toInt(),
    json['has_next_page'] as bool,
    (json['current_page'] as num).toInt(),
    JKPaginationItem.fromJson(json['items'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKPaginationToJson(JKPagination instance) =>
      <String, dynamic>{
        'last_visible_page': instance.lastVisiblePage,
        'has_next_page': instance.hasNextPage,
        'current_page': instance.currentPage,
        'items': instance.items.toJson(),
      };
  
  JKPaginationItem _$JKPaginationItemFromJson(Map<String, dynamic> json) =>
      JKPaginationItem(
        (json['count'] as num).toInt(),
        (json['total'] as num).toInt(),
        (json['per_page'] as num).toInt(),
      );
  
  Map<String, dynamic> _$JKPaginationItemToJson(JKPaginationItem instance) =>
      <String, dynamic>{
        'count': instance.count,
        'total': instance.total,
        'per_page': instance.perPage,
      };
  
  JKData _$JKDataFromJson(Map<String, dynamic> json) =>
      JKData(
          malId: (json['mal_id'] as num).toInt(),
          url: json['url'] as String,
          images: JKImage.fromJson(json['images'] as Map<String, dynamic>),
          trailer: json['trailer'] == null
              ? null
              : JKTrailer.fromJson(json['trailer'] as Map<String, dynamic>),
          approved: json['approved'] as bool?,
          titles: (json['titles'] as List<dynamic>?)
              ?.map((e) => JKTitle.fromJson(e as Map<String, dynamic>))
              .toList(),
          title: json['title'] as String?,
          titleEnglish: json['title_english'] as String?,
          titleJapanese: json['title_japanese'] as String?,
          titleSynonyms: (json['title_synonyms'] as List<dynamic>?)
              ?.map((e) => e as String)
              .toList(),
          type: json['type'] as String?,
          source: json['source'] as String?,
          episodes: (json['episodes'] as num?)?.toInt(),
          chapters: (json['chapters'] as num?)?.toInt(),
          volumes: (json['volumes'] as num?)?.toInt(),
          status: json['status'] as String?,
          airing: json['airing'] as bool?,
          aired: json['aired'] == null
              ? null
              : JKAired.fromJson(json['aired'] as Map<String, dynamic>),
          duration: json['duration'] as String?,
          rating: json['rating'] as String?,
          score: (json['score'] as num?)?.toDouble(),
          scoredBy: (json['scored_by'] as num?)?.toInt(),
          rank: (json['rank'] as num?)?.toInt(),
          popularity: (json['popularity'] as num?)?.toInt(),
          members: (json['members'] as num?)?.toInt(),
          favorites: (json['favorites'] as num?)?.toInt(),
          synopsis: json['synopsis'] as String?,
          background: json['background'] as String?,
          season: json['season'] as String?,
          year: (json['year'] as num?)?.toInt(),
          broadcast: json['broadcast'] == null
              ? null
              : JKBroadcast.fromJson(json['broadcast'] as Map<String, dynamic>),
          producers: (json['producers'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          licensors: (json['licensors'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          studios: (json['studios'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          demographics: (json['demographics'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          relations: (json['relations'] as List<dynamic>?)
              ?.map((e) => JKRelation.fromJson(e as Map<String, dynamic>))
              .toList(),
          theme: json['theme'] == null
              ? null
              : JKTheme.fromJson(json['theme'] as Map<String, dynamic>),
          external: (json['external'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          streaming: (json['streaming'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          publishing: json['publishing'] as bool?,
          published: json['published'] == null
              ? null
              : JKPublished.fromJson(json['published'] as Map<String, dynamic>),
          scored: (json['scored'] as num?)?.toDouble(),
          authors: (json['authors'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          serializations: (json['serializations'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          genres: (json['genres'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          explicitGenres: json['explicit_genres'] as List<dynamic>?,
          themes: (json['themes'] as List<dynamic>?)
              ?.map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
              .toList(),
          name: json['name'] as String?,
          nameKanji: json['name_kanji'] as String?,
          nicknames: (json['nicknames'] as List<dynamic>?)
              ?.map((e) => e as String)
              .toList(),
          about: json['about'] as String?,
          givenName: json['given_name'] as String?,
          familyName: json['family_name'] as String?,
          alternateNames: (json['alternate_names'] as List<dynamic>?)
              ?.map((e) => e as String)
              .toList(),
          birthday: json['birthday'] as String?,
        )
        ..anime = (json['anime'] as List<dynamic>?)
            ?.map((e) => JKOuterAnime.fromJson(e as Map<String, dynamic>))
            .toList()
        ..manga = (json['manga'] as List<dynamic>?)
            ?.map((e) => JKOuterAnime.fromJson(e as Map<String, dynamic>))
            .toList()
        ..voices = (json['voices'] as List<dynamic>?)
            ?.map((e) => JKOuterVoice.fromJson(e as Map<String, dynamic>))
            .toList();
  
  Map<String, dynamic> _$JKDataToJson(JKData instance) => <String, dynamic>{
    'mal_id': instance.malId,
    'url': instance.url,
    'images': instance.images.toJson(),
    'trailer': instance.trailer?.toJson(),
    'approved': instance.approved,
    'titles': instance.titles?.map((e) => e.toJson()).toList(),
    'title': instance.title,
    'title_english': instance.titleEnglish,
    'title_japanese': instance.titleJapanese,
    'title_synonyms': instance.titleSynonyms,
    'type': instance.type,
    'source': instance.source,
    'episodes': instance.episodes,
    'chapters': instance.chapters,
    'volumes': instance.volumes,
    'status': instance.status,
    'airing': instance.airing,
    'aired': instance.aired?.toJson(),
    'duration': instance.duration,
    'rating': instance.rating,
    'score': instance.score,
    'scored_by': instance.scoredBy,
    'rank': instance.rank,
    'popularity': instance.popularity,
    'members': instance.members,
    'favorites': instance.favorites,
    'synopsis': instance.synopsis,
    'background': instance.background,
    'season': instance.season,
    'year': instance.year,
    'broadcast': instance.broadcast?.toJson(),
    'producers': instance.producers?.map((e) => e.toJson()).toList(),
    'licensors': instance.licensors?.map((e) => e.toJson()).toList(),
    'studios': instance.studios?.map((e) => e.toJson()).toList(),
    'demographics': instance.demographics?.map((e) => e.toJson()).toList(),
    'relations': instance.relations?.map((e) => e.toJson()).toList(),
    'theme': instance.theme?.toJson(),
    'external': instance.external?.map((e) => e.toJson()).toList(),
    'streaming': instance.streaming?.map((e) => e.toJson()).toList(),
    'publishing': instance.publishing,
    'published': instance.published?.toJson(),
    'scored': instance.scored,
    'authors': instance.authors?.map((e) => e.toJson()).toList(),
    'serializations': instance.serializations?.map((e) => e.toJson()).toList(),
    'genres': instance.genres?.map((e) => e.toJson()).toList(),
    'explicit_genres': instance.explicitGenres,
    'themes': instance.themes?.map((e) => e.toJson()).toList(),
    'name': instance.name,
    'name_kanji': instance.nameKanji,
    'nicknames': instance.nicknames,
    'about': instance.about,
    'anime': instance.anime?.map((e) => e.toJson()).toList(),
    'manga': instance.manga?.map((e) => e.toJson()).toList(),
    'voices': instance.voices?.map((e) => e.toJson()).toList(),
    'given_name': instance.givenName,
    'family_name': instance.familyName,
    'alternate_names': instance.alternateNames,
    'birthday': instance.birthday,
  };
  
  JKImage _$JKImageFromJson(Map<String, dynamic> json) => JKImage(
    jpg: json['jpg'] == null
        ? null
        : JKJpg.fromJson(json['jpg'] as Map<String, dynamic>),
    webp: json['webp'] == null
        ? null
        : JKWebp.fromJson(json['webp'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKImageToJson(JKImage instance) => <String, dynamic>{
    'jpg': instance.jpg?.toJson(),
    'webp': instance.webp?.toJson(),
  };
  
  JKJpg _$JKJpgFromJson(Map<String, dynamic> json) => JKJpg(
    imageUrl: json['image_url'] as String?,
    smallImageUrl: json['small_image_url'] as String?,
    largeImageUrl: json['large_image_url'] as String?,
  );
  
  Map<String, dynamic> _$JKJpgToJson(JKJpg instance) => <String, dynamic>{
    'image_url': instance.imageUrl,
    'small_image_url': instance.smallImageUrl,
    'large_image_url': instance.largeImageUrl,
  };
  
  JKWebp _$JKWebpFromJson(Map<String, dynamic> json) => JKWebp(
    imageUrl: json['image_url'] as String?,
    smallImageUrl: json['small_image_url'] as String?,
    largeImageUrl: json['large_image_url'] as String?,
  );
  
  Map<String, dynamic> _$JKWebpToJson(JKWebp instance) => <String, dynamic>{
    'image_url': instance.imageUrl,
    'small_image_url': instance.smallImageUrl,
    'large_image_url': instance.largeImageUrl,
  };
  
  JKTrailer _$JKTrailerFromJson(Map<String, dynamic> json) => JKTrailer(
    youtubeId: json['youtube_id'] as String?,
    url: json['url'] as String?,
    embedUrl: json['embed_url'] as String?,
    images: json['images'] == null
        ? null
        : JKTrailerImage.fromJson(json['images'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKTrailerToJson(JKTrailer instance) => <String, dynamic>{
    'youtube_id': instance.youtubeId,
    'url': instance.url,
    'embed_url': instance.embedUrl,
    'images': instance.images?.toJson(),
  };
  
  JKTrailerImage _$JKTrailerImageFromJson(Map<String, dynamic> json) =>
      JKTrailerImage(
        imageUrl: json['image_url'] as String?,
        smallImageUrl: json['small_image_url'] as String?,
        mediumImageUrl: json['medium_image_url'] as String?,
        largeImageUrl: json['large_image_url'] as String?,
        maximumImageUrl: json['maximum_image_url'] as String?,
      );
  
  Map<String, dynamic> _$JKTrailerImageToJson(JKTrailerImage instance) =>
      <String, dynamic>{
        'image_url': instance.imageUrl,
        'small_image_url': instance.smallImageUrl,
        'medium_image_url': instance.mediumImageUrl,
        'large_image_url': instance.largeImageUrl,
        'maximum_image_url': instance.maximumImageUrl,
      };
  
  JKTitle _$JKTitleFromJson(Map<String, dynamic> json) =>
      JKTitle(type: json['type'] as String?, title: json['title'] as String?);
  
  Map<String, dynamic> _$JKTitleToJson(JKTitle instance) => <String, dynamic>{
    'type': instance.type,
    'title': instance.title,
  };
  
  JKAired _$JKAiredFromJson(Map<String, dynamic> json) => JKAired(
    from: json['from'] as String?,
    to: json['to'] as String?,
    prop: json['prop'] == null
        ? null
        : JKProp.fromJson(json['prop'] as Map<String, dynamic>),
    string: json['string'] as String?,
  );
  
  Map<String, dynamic> _$JKAiredToJson(JKAired instance) => <String, dynamic>{
    'from': instance.from,
    'to': instance.to,
    'prop': instance.prop?.toJson(),
    'string': instance.string,
  };
  
  JKProp _$JKPropFromJson(Map<String, dynamic> json) => JKProp(
    from: json['from'] == null
        ? null
        : JKDate.fromJson(json['from'] as Map<String, dynamic>),
    to: json['to'] == null
        ? null
        : JKDate.fromJson(json['to'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKPropToJson(JKProp instance) => <String, dynamic>{
    'from': instance.from?.toJson(),
    'to': instance.to?.toJson(),
  };
  
  JKDate _$JKDateFromJson(Map<String, dynamic> json) => JKDate(
    (json['day'] as num?)?.toInt(),
    (json['month'] as num?)?.toInt(),
    (json['year'] as num?)?.toInt(),
  );
  
  Map<String, dynamic> _$JKDateToJson(JKDate instance) => <String, dynamic>{
    'day': instance.day,
    'month': instance.month,
    'year': instance.year,
  };
  
  JKBroadcast _$JKBroadcastFromJson(Map<String, dynamic> json) => JKBroadcast(
    day: json['day'] as String?,
    time: json['time'] as String?,
    timezone: json['timezone'] as String?,
    string: json['string'] as String?,
  );
  
  Map<String, dynamic> _$JKBroadcastToJson(JKBroadcast instance) =>
      <String, dynamic>{
        'day': instance.day,
        'time': instance.time,
        'timezone': instance.timezone,
        'string': instance.string,
      };
  
  JKCusItem _$JKCusItemFromJson(Map<String, dynamic> json) => JKCusItem(
    malId: (json['mal_id'] as num?)?.toInt(),
    type: json['type'] as String?,
    name: json['name'] as String?,
    url: json['url'] as String?,
  );
  
  Map<String, dynamic> _$JKCusItemToJson(JKCusItem instance) => <String, dynamic>{
    'mal_id': instance.malId,
    'type': instance.type,
    'name': instance.name,
    'url': instance.url,
  };
  
  JKPublished _$JKPublishedFromJson(Map<String, dynamic> json) => JKPublished(
    from: json['from'] as String?,
    to: json['to'] as String?,
    prop: json['prop'] == null
        ? null
        : JKProp.fromJson(json['prop'] as Map<String, dynamic>),
    string: json['string'] as String?,
  );
  
  Map<String, dynamic> _$JKPublishedToJson(JKPublished instance) =>
      <String, dynamic>{
        'from': instance.from,
        'to': instance.to,
        'prop': instance.prop?.toJson(),
        'string': instance.string,
      };
  
  JKRelation _$JKRelationFromJson(Map<String, dynamic> json) => JKRelation(
    json['relation'] as String,
    (json['entry'] as List<dynamic>)
        .map((e) => JKCusItem.fromJson(e as Map<String, dynamic>))
        .toList(),
  );
  
  Map<String, dynamic> _$JKRelationToJson(JKRelation instance) =>
      <String, dynamic>{
        'relation': instance.relation,
        'entry': instance.entry.map((e) => e.toJson()).toList(),
      };
  
  JKTheme _$JKThemeFromJson(Map<String, dynamic> json) => JKTheme(
    openings: (json['openings'] as List<dynamic>?)
        ?.map((e) => e as String)
        .toList(),
    endings: (json['endings'] as List<dynamic>?)
        ?.map((e) => e as String)
        .toList(),
  );
  
  Map<String, dynamic> _$JKThemeToJson(JKTheme instance) => <String, dynamic>{
    'openings': instance.openings,
    'endings': instance.endings,
  };
  
  JKOuterAnime _$JKOuterAnimeFromJson(Map<String, dynamic> json) => JKOuterAnime(
    role: json['role'] as String?,
    position: json['position'] as String?,
    anime: json['anime'] == null
        ? null
        : JKInnerItem.fromJson(json['anime'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKOuterAnimeToJson(JKOuterAnime instance) =>
      <String, dynamic>{
        'role': instance.role,
        'position': instance.position,
        'anime': instance.anime?.toJson(),
      };
  
  JKOuterVoice _$JKOuterVoiceFromJson(Map<String, dynamic> json) => JKOuterVoice(
    language: json['language'] as String?,
    person: json['person'] == null
        ? null
        : JKInnerItem.fromJson(json['person'] as Map<String, dynamic>),
    role: json['role'] as String?,
    anime: json['anime'] == null
        ? null
        : JKInnerItem.fromJson(json['anime'] as Map<String, dynamic>),
    character: json['character'] == null
        ? null
        : JKInnerItem.fromJson(json['character'] as Map<String, dynamic>),
  );
  
  Map<String, dynamic> _$JKOuterVoiceToJson(JKOuterVoice instance) =>
      <String, dynamic>{
        'language': instance.language,
        'person': instance.person?.toJson(),
        'role': instance.role,
        'anime': instance.anime?.toJson(),
        'character': instance.character?.toJson(),
      };
  
  JKInnerItem _$JKInnerItemFromJson(Map<String, dynamic> json) => JKInnerItem(
    malId: (json['mal_id'] as num?)?.toInt(),
    url: json['url'] as String?,
    images: json['images'] == null
        ? null
        : JKImage.fromJson(json['images'] as Map<String, dynamic>),
    title: json['title'] as String?,
    name: json['name'] as String?,
  );
  
  Map<String, dynamic> _$JKInnerItemToJson(JKInnerItem instance) =>
      <String, dynamic>{
        'mal_id': instance.malId,
        'url': instance.url,
        'images': instance.images?.toJson(),
        'title': instance.title,
        'name': instance.name,
      };
  
  JikanSeasonResp _$JikanSeasonRespFromJson(Map<String, dynamic> json) =>
      JikanSeasonResp(
        JKSeasonPagination.fromJson(json['pagination'] as Map<String, dynamic>),
        (json['data'] as List<dynamic>)
            .map((e) => JKSeason.fromJson(e as Map<String, dynamic>))
            .toList(),
      );
  
  Map<String, dynamic> _$JikanSeasonRespToJson(JikanSeasonResp instance) =>
      <String, dynamic>{
        'pagination': instance.pagination.toJson(),
        'data': instance.data.map((e) => e.toJson()).toList(),
      };
  
  JKSeasonPagination _$JKSeasonPaginationFromJson(Map<String, dynamic> json) =>
      JKSeasonPagination(
        (json['last_visible_page'] as num?)?.toInt(),
        json['has_next_page'] as bool?,
      );
  
  Map<String, dynamic> _$JKSeasonPaginationToJson(JKSeasonPagination instance) =>
      <String, dynamic>{
        'last_visible_page': instance.lastVisiblePage,
        'has_next_page': instance.hasNextPage,
      };
  
  JKSeason _$JKSeasonFromJson(Map<String, dynamic> json) => JKSeason(
    (json['year'] as num).toInt(),
    (json['seasons'] as List<dynamic>).map((e) => e as String).toList(),
  );
  
  Map<String, dynamic> _$JKSeasonToJson(JKSeason instance) => <String, dynamic>{
    'year': instance.year,
    'seasons': instance.seasons,
  };
  