// Code generated by github.com/Yamashou/gqlgenc, DO NOT EDIT.

package anilist

import (
	"context"
	"net/http"

	"github.com/Yamashou/gqlgenc/clientv2"
)

type GithubGraphQLClient interface {
	AnimeCollection(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*AnimeCollection, error)
	AnimeCollectionWithRelations(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*AnimeCollectionWithRelations, error)
	BaseAnimeByMalID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseAnimeByMalID, error)
	BaseAnimeByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseAnimeByID, error)
	SearchBaseAnimeByIds(ctx context.Context, ids []*int, page *int, perPage *int, status []*MediaStatus, inCollection *bool, sort []*MediaSort, season *MediaSeason, year *int, genre *string, format *MediaFormat, interceptors ...clientv2.RequestInterceptor) (*SearchBaseAnimeByIds, error)
	CompleteAnimeByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*CompleteAnimeByID, error)
	AnimeDetailsByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*AnimeDetailsByID, error)
	ListAnime(ctx context.Context, page *int, search *string, perPage *int, sort []*MediaSort, status []*MediaStatus, genres []*string, averageScoreGreater *int, season *MediaSeason, seasonYear *int, format *MediaFormat, isAdult *bool, interceptors ...clientv2.RequestInterceptor) (*ListAnime, error)
	ListRecentAnime(ctx context.Context, page *int, perPage *int, airingAtGreater *int, airingAtLesser *int, notYetAired *bool, interceptors ...clientv2.RequestInterceptor) (*ListRecentAnime, error)
	AnimeAiringSchedule(ctx context.Context, ids []*int, season *MediaSeason, seasonYear *int, previousSeason *MediaSeason, previousSeasonYear *int, nextSeason *MediaSeason, nextSeasonYear *int, interceptors ...clientv2.RequestInterceptor) (*AnimeAiringSchedule, error)
	AnimeAiringScheduleRaw(ctx context.Context, ids []*int, interceptors ...clientv2.RequestInterceptor) (*AnimeAiringScheduleRaw, error)
	UpdateMediaListEntry(ctx context.Context, mediaID *int, status *MediaListStatus, scoreRaw *int, progress *int, startedAt *FuzzyDateInput, completedAt *FuzzyDateInput, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntry, error)
	UpdateMediaListEntryProgress(ctx context.Context, mediaID *int, progress *int, status *MediaListStatus, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntryProgress, error)
	DeleteEntry(ctx context.Context, mediaListEntryID *int, interceptors ...clientv2.RequestInterceptor) (*DeleteEntry, error)
	UpdateMediaListEntryRepeat(ctx context.Context, mediaID *int, repeat *int, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntryRepeat, error)
	MangaCollection(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*MangaCollection, error)
	SearchBaseManga(ctx context.Context, page *int, perPage *int, sort []*MediaSort, search *string, status []*MediaStatus, interceptors ...clientv2.RequestInterceptor) (*SearchBaseManga, error)
	BaseMangaByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseMangaByID, error)
	MangaDetailsByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*MangaDetailsByID, error)
	ListManga(ctx context.Context, page *int, search *string, perPage *int, sort []*MediaSort, status []*MediaStatus, genres []*string, averageScoreGreater *int, startDateGreater *string, startDateLesser *string, format *MediaFormat, countryOfOrigin *string, isAdult *bool, interceptors ...clientv2.RequestInterceptor) (*ListManga, error)
	ViewerStats(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*ViewerStats, error)
	StudioDetails(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*StudioDetails, error)
	GetViewer(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetViewer, error)
}

type Client struct {
	Client *clientv2.Client
}

func NewClient(cli *http.Client, baseURL string, options *clientv2.Options, interceptors ...clientv2.RequestInterceptor) GithubGraphQLClient {
	return &Client{Client: clientv2.NewClient(cli, baseURL, options, interceptors...)}
}

type BaseAnime struct {
	ID                int                          "json:\"id\" graphql:\"id\""
	IDMal             *int                         "json:\"idMal,omitempty\" graphql:\"idMal\""
	SiteURL           *string                      "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	Status            *MediaStatus                 "json:\"status,omitempty\" graphql:\"status\""
	Season            *MediaSeason                 "json:\"season,omitempty\" graphql:\"season\""
	Type              *MediaType                   "json:\"type,omitempty\" graphql:\"type\""
	Format            *MediaFormat                 "json:\"format,omitempty\" graphql:\"format\""
	SeasonYear        *int                         "json:\"seasonYear,omitempty\" graphql:\"seasonYear\""
	BannerImage       *string                      "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	Episodes          *int                         "json:\"episodes,omitempty\" graphql:\"episodes\""
	Synonyms          []*string                    "json:\"synonyms,omitempty\" graphql:\"synonyms\""
	IsAdult           *bool                        "json:\"isAdult,omitempty\" graphql:\"isAdult\""
	CountryOfOrigin   *string                      "json:\"countryOfOrigin,omitempty\" graphql:\"countryOfOrigin\""
	MeanScore         *int                         "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description       *string                      "json:\"description,omitempty\" graphql:\"description\""
	Genres            []*string                    "json:\"genres,omitempty\" graphql:\"genres\""
	Duration          *int                         "json:\"duration,omitempty\" graphql:\"duration\""
	Trailer           *BaseAnime_Trailer           "json:\"trailer,omitempty\" graphql:\"trailer\""
	Title             *BaseAnime_Title             "json:\"title,omitempty\" graphql:\"title\""
	CoverImage        *BaseAnime_CoverImage        "json:\"coverImage,omitempty\" graphql:\"coverImage\""
	StartDate         *BaseAnime_StartDate         "json:\"startDate,omitempty\" graphql:\"startDate\""
	EndDate           *BaseAnime_EndDate           "json:\"endDate,omitempty\" graphql:\"endDate\""
	NextAiringEpisode *BaseAnime_NextAiringEpisode "json:\"nextAiringEpisode,omitempty\" graphql:\"nextAiringEpisode\""
}

func (t *BaseAnime) GetID() int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.ID
}
func (t *BaseAnime) GetIDMal() *int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.IDMal
}
func (t *BaseAnime) GetSiteURL() *string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.SiteURL
}
func (t *BaseAnime) GetStatus() *MediaStatus {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Status
}
func (t *BaseAnime) GetSeason() *MediaSeason {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Season
}
func (t *BaseAnime) GetType() *MediaType {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Type
}
func (t *BaseAnime) GetFormat() *MediaFormat {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Format
}
func (t *BaseAnime) GetSeasonYear() *int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.SeasonYear
}
func (t *BaseAnime) GetBannerImage() *string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.BannerImage
}
func (t *BaseAnime) GetEpisodes() *int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Episodes
}
func (t *BaseAnime) GetSynonyms() []*string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Synonyms
}
func (t *BaseAnime) GetIsAdult() *bool {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.IsAdult
}
func (t *BaseAnime) GetCountryOfOrigin() *string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.CountryOfOrigin
}
func (t *BaseAnime) GetMeanScore() *int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.MeanScore
}
func (t *BaseAnime) GetDescription() *string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Description
}
func (t *BaseAnime) GetGenres() []*string {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Genres
}
func (t *BaseAnime) GetDuration() *int {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Duration
}
func (t *BaseAnime) GetTrailer() *BaseAnime_Trailer {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Trailer
}
func (t *BaseAnime) GetTitle() *BaseAnime_Title {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.Title
}
func (t *BaseAnime) GetCoverImage() *BaseAnime_CoverImage {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.CoverImage
}
func (t *BaseAnime) GetStartDate() *BaseAnime_StartDate {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.StartDate
}
func (t *BaseAnime) GetEndDate() *BaseAnime_EndDate {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.EndDate
}
func (t *BaseAnime) GetNextAiringEpisode() *BaseAnime_NextAiringEpisode {
	if t == nil {
		t = &BaseAnime{}
	}
	return t.NextAiringEpisode
}

type CompleteAnime struct {
	ID                int                              "json:\"id\" graphql:\"id\""
	IDMal             *int                             "json:\"idMal,omitempty\" graphql:\"idMal\""
	SiteURL           *string                          "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	Status            *MediaStatus                     "json:\"status,omitempty\" graphql:\"status\""
	Season            *MediaSeason                     "json:\"season,omitempty\" graphql:\"season\""
	SeasonYear        *int                             "json:\"seasonYear,omitempty\" graphql:\"seasonYear\""
	Type              *MediaType                       "json:\"type,omitempty\" graphql:\"type\""
	Format            *MediaFormat                     "json:\"format,omitempty\" graphql:\"format\""
	BannerImage       *string                          "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	Episodes          *int                             "json:\"episodes,omitempty\" graphql:\"episodes\""
	Synonyms          []*string                        "json:\"synonyms,omitempty\" graphql:\"synonyms\""
	IsAdult           *bool                            "json:\"isAdult,omitempty\" graphql:\"isAdult\""
	CountryOfOrigin   *string                          "json:\"countryOfOrigin,omitempty\" graphql:\"countryOfOrigin\""
	MeanScore         *int                             "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description       *string                          "json:\"description,omitempty\" graphql:\"description\""
	Genres            []*string                        "json:\"genres,omitempty\" graphql:\"genres\""
	Duration          *int                             "json:\"duration,omitempty\" graphql:\"duration\""
	Trailer           *CompleteAnime_Trailer           "json:\"trailer,omitempty\" graphql:\"trailer\""
	Title             *CompleteAnime_Title             "json:\"title,omitempty\" graphql:\"title\""
	CoverImage        *CompleteAnime_CoverImage        "json:\"coverImage,omitempty\" graphql:\"coverImage\""
	StartDate         *CompleteAnime_StartDate         "json:\"startDate,omitempty\" graphql:\"startDate\""
	EndDate           *CompleteAnime_EndDate           "json:\"endDate,omitempty\" graphql:\"endDate\""
	NextAiringEpisode *CompleteAnime_NextAiringEpisode "json:\"nextAiringEpisode,omitempty\" graphql:\"nextAiringEpisode\""
	Relations         *CompleteAnime_Relations         "json:\"relations,omitempty\" graphql:\"relations\""
}

func (t *CompleteAnime) GetID() int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.ID
}
func (t *CompleteAnime) GetIDMal() *int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.IDMal
}
func (t *CompleteAnime) GetSiteURL() *string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.SiteURL
}
func (t *CompleteAnime) GetStatus() *MediaStatus {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Status
}
func (t *CompleteAnime) GetSeason() *MediaSeason {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Season
}
func (t *CompleteAnime) GetSeasonYear() *int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.SeasonYear
}
func (t *CompleteAnime) GetType() *MediaType {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Type
}
func (t *CompleteAnime) GetFormat() *MediaFormat {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Format
}
func (t *CompleteAnime) GetBannerImage() *string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.BannerImage
}
func (t *CompleteAnime) GetEpisodes() *int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Episodes
}
func (t *CompleteAnime) GetSynonyms() []*string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Synonyms
}
func (t *CompleteAnime) GetIsAdult() *bool {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.IsAdult
}
func (t *CompleteAnime) GetCountryOfOrigin() *string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.CountryOfOrigin
}
func (t *CompleteAnime) GetMeanScore() *int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.MeanScore
}
func (t *CompleteAnime) GetDescription() *string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Description
}
func (t *CompleteAnime) GetGenres() []*string {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Genres
}
func (t *CompleteAnime) GetDuration() *int {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Duration
}
func (t *CompleteAnime) GetTrailer() *CompleteAnime_Trailer {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Trailer
}
func (t *CompleteAnime) GetTitle() *CompleteAnime_Title {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Title
}
func (t *CompleteAnime) GetCoverImage() *CompleteAnime_CoverImage {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.CoverImage
}
func (t *CompleteAnime) GetStartDate() *CompleteAnime_StartDate {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.StartDate
}
func (t *CompleteAnime) GetEndDate() *CompleteAnime_EndDate {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.EndDate
}
func (t *CompleteAnime) GetNextAiringEpisode() *CompleteAnime_NextAiringEpisode {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.NextAiringEpisode
}
func (t *CompleteAnime) GetRelations() *CompleteAnime_Relations {
	if t == nil {
		t = &CompleteAnime{}
	}
	return t.Relations
}

type BaseCharacter struct {
	ID          int                        "json:\"id\" graphql:\"id\""
	IsFavourite bool                       "json:\"isFavourite\" graphql:\"isFavourite\""
	Gender      *string                    "json:\"gender,omitempty\" graphql:\"gender\""
	Age         *string                    "json:\"age,omitempty\" graphql:\"age\""
	DateOfBirth *BaseCharacter_DateOfBirth "json:\"dateOfBirth,omitempty\" graphql:\"dateOfBirth\""
	Name        *BaseCharacter_Name        "json:\"name,omitempty\" graphql:\"name\""
	Image       *BaseCharacter_Image       "json:\"image,omitempty\" graphql:\"image\""
	Description *string                    "json:\"description,omitempty\" graphql:\"description\""
	SiteURL     *string                    "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
}

func (t *BaseCharacter) GetID() int {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.ID
}
func (t *BaseCharacter) GetIsFavourite() bool {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.IsFavourite
}
func (t *BaseCharacter) GetGender() *string {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.Gender
}
func (t *BaseCharacter) GetAge() *string {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.Age
}
func (t *BaseCharacter) GetDateOfBirth() *BaseCharacter_DateOfBirth {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.DateOfBirth
}
func (t *BaseCharacter) GetName() *BaseCharacter_Name {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.Name
}
func (t *BaseCharacter) GetImage() *BaseCharacter_Image {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.Image
}
func (t *BaseCharacter) GetDescription() *string {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.Description
}
func (t *BaseCharacter) GetSiteURL() *string {
	if t == nil {
		t = &BaseCharacter{}
	}
	return t.SiteURL
}

type AnimeSchedule struct {
	ID       int                     "json:\"id\" graphql:\"id\""
	IDMal    *int                    "json:\"idMal,omitempty\" graphql:\"idMal\""
	Previous *AnimeSchedule_Previous "json:\"previous,omitempty\" graphql:\"previous\""
	Upcoming *AnimeSchedule_Upcoming "json:\"upcoming,omitempty\" graphql:\"upcoming\""
}

func (t *AnimeSchedule) GetID() int {
	if t == nil {
		t = &AnimeSchedule{}
	}
	return t.ID
}
func (t *AnimeSchedule) GetIDMal() *int {
	if t == nil {
		t = &AnimeSchedule{}
	}
	return t.IDMal
}
func (t *AnimeSchedule) GetPrevious() *AnimeSchedule_Previous {
	if t == nil {
		t = &AnimeSchedule{}
	}
	return t.Previous
}
func (t *AnimeSchedule) GetUpcoming() *AnimeSchedule_Upcoming {
	if t == nil {
		t = &AnimeSchedule{}
	}
	return t.Upcoming
}

type BaseManga struct {
	ID              int                   "json:\"id\" graphql:\"id\""
	IDMal           *int                  "json:\"idMal,omitempty\" graphql:\"idMal\""
	SiteURL         *string               "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	Status          *MediaStatus          "json:\"status,omitempty\" graphql:\"status\""
	Season          *MediaSeason          "json:\"season,omitempty\" graphql:\"season\""
	Type            *MediaType            "json:\"type,omitempty\" graphql:\"type\""
	Format          *MediaFormat          "json:\"format,omitempty\" graphql:\"format\""
	BannerImage     *string               "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	Chapters        *int                  "json:\"chapters,omitempty\" graphql:\"chapters\""
	Volumes         *int                  "json:\"volumes,omitempty\" graphql:\"volumes\""
	Synonyms        []*string             "json:\"synonyms,omitempty\" graphql:\"synonyms\""
	IsAdult         *bool                 "json:\"isAdult,omitempty\" graphql:\"isAdult\""
	CountryOfOrigin *string               "json:\"countryOfOrigin,omitempty\" graphql:\"countryOfOrigin\""
	MeanScore       *int                  "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description     *string               "json:\"description,omitempty\" graphql:\"description\""
	Genres          []*string             "json:\"genres,omitempty\" graphql:\"genres\""
	Title           *BaseManga_Title      "json:\"title,omitempty\" graphql:\"title\""
	CoverImage      *BaseManga_CoverImage "json:\"coverImage,omitempty\" graphql:\"coverImage\""
	StartDate       *BaseManga_StartDate  "json:\"startDate,omitempty\" graphql:\"startDate\""
	EndDate         *BaseManga_EndDate    "json:\"endDate,omitempty\" graphql:\"endDate\""
}

func (t *BaseManga) GetID() int {
	if t == nil {
		t = &BaseManga{}
	}
	return t.ID
}
func (t *BaseManga) GetIDMal() *int {
	if t == nil {
		t = &BaseManga{}
	}
	return t.IDMal
}
func (t *BaseManga) GetSiteURL() *string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.SiteURL
}
func (t *BaseManga) GetStatus() *MediaStatus {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Status
}
func (t *BaseManga) GetSeason() *MediaSeason {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Season
}
func (t *BaseManga) GetType() *MediaType {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Type
}
func (t *BaseManga) GetFormat() *MediaFormat {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Format
}
func (t *BaseManga) GetBannerImage() *string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.BannerImage
}
func (t *BaseManga) GetChapters() *int {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Chapters
}
func (t *BaseManga) GetVolumes() *int {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Volumes
}
func (t *BaseManga) GetSynonyms() []*string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Synonyms
}
func (t *BaseManga) GetIsAdult() *bool {
	if t == nil {
		t = &BaseManga{}
	}
	return t.IsAdult
}
func (t *BaseManga) GetCountryOfOrigin() *string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.CountryOfOrigin
}
func (t *BaseManga) GetMeanScore() *int {
	if t == nil {
		t = &BaseManga{}
	}
	return t.MeanScore
}
func (t *BaseManga) GetDescription() *string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Description
}
func (t *BaseManga) GetGenres() []*string {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Genres
}
func (t *BaseManga) GetTitle() *BaseManga_Title {
	if t == nil {
		t = &BaseManga{}
	}
	return t.Title
}
func (t *BaseManga) GetCoverImage() *BaseManga_CoverImage {
	if t == nil {
		t = &BaseManga{}
	}
	return t.CoverImage
}
func (t *BaseManga) GetStartDate() *BaseManga_StartDate {
	if t == nil {
		t = &BaseManga{}
	}
	return t.StartDate
}
func (t *BaseManga) GetEndDate() *BaseManga_EndDate {
	if t == nil {
		t = &BaseManga{}
	}
	return t.EndDate
}

type UserFormatStats struct {
	Format         *MediaFormat "json:\"format,omitempty\" graphql:\"format\""
	MeanScore      float64      "json:\"meanScore\" graphql:\"meanScore\""
	Count          int          "json:\"count\" graphql:\"count\""
	MinutesWatched int          "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int       "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int          "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserFormatStats) GetFormat() *MediaFormat {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.Format
}
func (t *UserFormatStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.MeanScore
}
func (t *UserFormatStats) GetCount() int {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.Count
}
func (t *UserFormatStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.MinutesWatched
}
func (t *UserFormatStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.MediaIds
}
func (t *UserFormatStats) GetChaptersRead() int {
	if t == nil {
		t = &UserFormatStats{}
	}
	return t.ChaptersRead
}

type UserGenreStats struct {
	Genre          *string "json:\"genre,omitempty\" graphql:\"genre\""
	MeanScore      float64 "json:\"meanScore\" graphql:\"meanScore\""
	Count          int     "json:\"count\" graphql:\"count\""
	MinutesWatched int     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int  "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int     "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserGenreStats) GetGenre() *string {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.Genre
}
func (t *UserGenreStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.MeanScore
}
func (t *UserGenreStats) GetCount() int {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.Count
}
func (t *UserGenreStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.MinutesWatched
}
func (t *UserGenreStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.MediaIds
}
func (t *UserGenreStats) GetChaptersRead() int {
	if t == nil {
		t = &UserGenreStats{}
	}
	return t.ChaptersRead
}

type UserStatusStats struct {
	Status         *MediaListStatus "json:\"status,omitempty\" graphql:\"status\""
	MeanScore      float64          "json:\"meanScore\" graphql:\"meanScore\""
	Count          int              "json:\"count\" graphql:\"count\""
	MinutesWatched int              "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int           "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int              "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserStatusStats) GetStatus() *MediaListStatus {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.Status
}
func (t *UserStatusStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.MeanScore
}
func (t *UserStatusStats) GetCount() int {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.Count
}
func (t *UserStatusStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.MinutesWatched
}
func (t *UserStatusStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.MediaIds
}
func (t *UserStatusStats) GetChaptersRead() int {
	if t == nil {
		t = &UserStatusStats{}
	}
	return t.ChaptersRead
}

type UserScoreStats struct {
	Score          *int    "json:\"score,omitempty\" graphql:\"score\""
	MeanScore      float64 "json:\"meanScore\" graphql:\"meanScore\""
	Count          int     "json:\"count\" graphql:\"count\""
	MinutesWatched int     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int  "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int     "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserScoreStats) GetScore() *int {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.Score
}
func (t *UserScoreStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.MeanScore
}
func (t *UserScoreStats) GetCount() int {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.Count
}
func (t *UserScoreStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.MinutesWatched
}
func (t *UserScoreStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.MediaIds
}
func (t *UserScoreStats) GetChaptersRead() int {
	if t == nil {
		t = &UserScoreStats{}
	}
	return t.ChaptersRead
}

type UserStudioStats struct {
	Studio         *UserStudioStats_Studio "json:\"studio,omitempty\" graphql:\"studio\""
	MeanScore      float64                 "json:\"meanScore\" graphql:\"meanScore\""
	Count          int                     "json:\"count\" graphql:\"count\""
	MinutesWatched int                     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int                  "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int                     "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserStudioStats) GetStudio() *UserStudioStats_Studio {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.Studio
}
func (t *UserStudioStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.MeanScore
}
func (t *UserStudioStats) GetCount() int {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.Count
}
func (t *UserStudioStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.MinutesWatched
}
func (t *UserStudioStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.MediaIds
}
func (t *UserStudioStats) GetChaptersRead() int {
	if t == nil {
		t = &UserStudioStats{}
	}
	return t.ChaptersRead
}

type UserStartYearStats struct {
	StartYear      *int    "json:\"startYear,omitempty\" graphql:\"startYear\""
	MeanScore      float64 "json:\"meanScore\" graphql:\"meanScore\""
	Count          int     "json:\"count\" graphql:\"count\""
	MinutesWatched int     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int  "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int     "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserStartYearStats) GetStartYear() *int {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.StartYear
}
func (t *UserStartYearStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.MeanScore
}
func (t *UserStartYearStats) GetCount() int {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.Count
}
func (t *UserStartYearStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.MinutesWatched
}
func (t *UserStartYearStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.MediaIds
}
func (t *UserStartYearStats) GetChaptersRead() int {
	if t == nil {
		t = &UserStartYearStats{}
	}
	return t.ChaptersRead
}

type UserReleaseYearStats struct {
	ReleaseYear    *int    "json:\"releaseYear,omitempty\" graphql:\"releaseYear\""
	MeanScore      float64 "json:\"meanScore\" graphql:\"meanScore\""
	Count          int     "json:\"count\" graphql:\"count\""
	MinutesWatched int     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	MediaIds       []*int  "json:\"mediaIds\" graphql:\"mediaIds\""
	ChaptersRead   int     "json:\"chaptersRead\" graphql:\"chaptersRead\""
}

func (t *UserReleaseYearStats) GetReleaseYear() *int {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.ReleaseYear
}
func (t *UserReleaseYearStats) GetMeanScore() float64 {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.MeanScore
}
func (t *UserReleaseYearStats) GetCount() int {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.Count
}
func (t *UserReleaseYearStats) GetMinutesWatched() int {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.MinutesWatched
}
func (t *UserReleaseYearStats) GetMediaIds() []*int {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.MediaIds
}
func (t *UserReleaseYearStats) GetChaptersRead() int {
	if t == nil {
		t = &UserReleaseYearStats{}
	}
	return t.ChaptersRead
}

type BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &BaseAnime_Title{}
	}
	return t.English
}
func (t *BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &BaseAnime_Title{}
	}
	return t.Native
}

type BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &BaseAnime_CoverImage{}
	}
	return t.Color
}

type BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &BaseAnime_StartDate{}
	}
	return t.Day
}

type BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &BaseAnime_EndDate{}
	}
	return t.Day
}

type BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type CompleteAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *CompleteAnime_Trailer) GetID() *string {
	if t == nil {
		t = &CompleteAnime_Trailer{}
	}
	return t.ID
}
func (t *CompleteAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &CompleteAnime_Trailer{}
	}
	return t.Site
}
func (t *CompleteAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &CompleteAnime_Trailer{}
	}
	return t.Thumbnail
}

type CompleteAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *CompleteAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &CompleteAnime_Title{}
	}
	return t.UserPreferred
}
func (t *CompleteAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &CompleteAnime_Title{}
	}
	return t.Romaji
}
func (t *CompleteAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &CompleteAnime_Title{}
	}
	return t.English
}
func (t *CompleteAnime_Title) GetNative() *string {
	if t == nil {
		t = &CompleteAnime_Title{}
	}
	return t.Native
}

type CompleteAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *CompleteAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &CompleteAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *CompleteAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &CompleteAnime_CoverImage{}
	}
	return t.Large
}
func (t *CompleteAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &CompleteAnime_CoverImage{}
	}
	return t.Medium
}
func (t *CompleteAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &CompleteAnime_CoverImage{}
	}
	return t.Color
}

type CompleteAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnime_StartDate{}
	}
	return t.Year
}
func (t *CompleteAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnime_StartDate{}
	}
	return t.Month
}
func (t *CompleteAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnime_StartDate{}
	}
	return t.Day
}

type CompleteAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnime_EndDate{}
	}
	return t.Year
}
func (t *CompleteAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnime_EndDate{}
	}
	return t.Month
}
func (t *CompleteAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnime_EndDate{}
	}
	return t.Day
}

type CompleteAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *CompleteAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &CompleteAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *CompleteAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &CompleteAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *CompleteAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &CompleteAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.English
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Native
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Color
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Day
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Day
}

type CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type CompleteAnime_Relations_Edges struct {
	RelationType *MediaRelation "json:\"relationType,omitempty\" graphql:\"relationType\""
	Node         *BaseAnime     "json:\"node,omitempty\" graphql:\"node\""
}

func (t *CompleteAnime_Relations_Edges) GetRelationType() *MediaRelation {
	if t == nil {
		t = &CompleteAnime_Relations_Edges{}
	}
	return t.RelationType
}
func (t *CompleteAnime_Relations_Edges) GetNode() *BaseAnime {
	if t == nil {
		t = &CompleteAnime_Relations_Edges{}
	}
	return t.Node
}

type CompleteAnime_Relations struct {
	Edges []*CompleteAnime_Relations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *CompleteAnime_Relations) GetEdges() []*CompleteAnime_Relations_Edges {
	if t == nil {
		t = &CompleteAnime_Relations{}
	}
	return t.Edges
}

type BaseCharacter_DateOfBirth struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseCharacter_DateOfBirth) GetYear() *int {
	if t == nil {
		t = &BaseCharacter_DateOfBirth{}
	}
	return t.Year
}
func (t *BaseCharacter_DateOfBirth) GetMonth() *int {
	if t == nil {
		t = &BaseCharacter_DateOfBirth{}
	}
	return t.Month
}
func (t *BaseCharacter_DateOfBirth) GetDay() *int {
	if t == nil {
		t = &BaseCharacter_DateOfBirth{}
	}
	return t.Day
}

type BaseCharacter_Name struct {
	Full        *string   "json:\"full,omitempty\" graphql:\"full\""
	Native      *string   "json:\"native,omitempty\" graphql:\"native\""
	Alternative []*string "json:\"alternative,omitempty\" graphql:\"alternative\""
}

func (t *BaseCharacter_Name) GetFull() *string {
	if t == nil {
		t = &BaseCharacter_Name{}
	}
	return t.Full
}
func (t *BaseCharacter_Name) GetNative() *string {
	if t == nil {
		t = &BaseCharacter_Name{}
	}
	return t.Native
}
func (t *BaseCharacter_Name) GetAlternative() []*string {
	if t == nil {
		t = &BaseCharacter_Name{}
	}
	return t.Alternative
}

type BaseCharacter_Image struct {
	Large *string "json:\"large,omitempty\" graphql:\"large\""
}

func (t *BaseCharacter_Image) GetLarge() *string {
	if t == nil {
		t = &BaseCharacter_Image{}
	}
	return t.Large
}

type AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeSchedule_Previous struct {
	Nodes []*AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeSchedule_Previous) GetNodes() []*AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeSchedule_Upcoming struct {
	Nodes []*AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeSchedule_Upcoming) GetNodes() []*AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &BaseManga_Title{}
	}
	return t.Romaji
}
func (t *BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &BaseManga_Title{}
	}
	return t.English
}
func (t *BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &BaseManga_Title{}
	}
	return t.Native
}

type BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &BaseManga_CoverImage{}
	}
	return t.Color
}

type BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &BaseManga_StartDate{}
	}
	return t.Year
}
func (t *BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &BaseManga_StartDate{}
	}
	return t.Month
}
func (t *BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &BaseManga_StartDate{}
	}
	return t.Day
}

type BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &BaseManga_EndDate{}
	}
	return t.Year
}
func (t *BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &BaseManga_EndDate{}
	}
	return t.Month
}
func (t *BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &BaseManga_EndDate{}
	}
	return t.Day
}

type UserStudioStats_Studio struct {
	ID                int    "json:\"id\" graphql:\"id\""
	Name              string "json:\"name\" graphql:\"name\""
	IsAnimationStudio bool   "json:\"isAnimationStudio\" graphql:\"isAnimationStudio\""
}

func (t *UserStudioStats_Studio) GetID() int {
	if t == nil {
		t = &UserStudioStats_Studio{}
	}
	return t.ID
}
func (t *UserStudioStats_Studio) GetName() string {
	if t == nil {
		t = &UserStudioStats_Studio{}
	}
	return t.Name
}
func (t *UserStudioStats_Studio) GetIsAnimationStudio() bool {
	if t == nil {
		t = &UserStudioStats_Studio{}
	}
	return t.IsAnimationStudio
}

type AnimeCollection_MediaListCollection_Lists_Entries_StartedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_StartedAt) GetYear() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Year
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_StartedAt) GetMonth() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Month
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_StartedAt) GetDay() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Day
}

type AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt) GetYear() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Year
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt) GetMonth() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Month
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt) GetDay() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Day
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_Title{}
	}
	return t.Native
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type AnimeCollection_MediaListCollection_Lists_Entries struct {
	ID          int                                                            "json:\"id\" graphql:\"id\""
	Score       *float64                                                       "json:\"score,omitempty\" graphql:\"score\""
	Progress    *int                                                           "json:\"progress,omitempty\" graphql:\"progress\""
	Status      *MediaListStatus                                               "json:\"status,omitempty\" graphql:\"status\""
	Notes       *string                                                        "json:\"notes,omitempty\" graphql:\"notes\""
	Repeat      *int                                                           "json:\"repeat,omitempty\" graphql:\"repeat\""
	Private     *bool                                                          "json:\"private,omitempty\" graphql:\"private\""
	StartedAt   *AnimeCollection_MediaListCollection_Lists_Entries_StartedAt   "json:\"startedAt,omitempty\" graphql:\"startedAt\""
	CompletedAt *AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt "json:\"completedAt,omitempty\" graphql:\"completedAt\""
	Media       *BaseAnime                                                     "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetID() int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.ID
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetScore() *float64 {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Score
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetProgress() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Progress
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetStatus() *MediaListStatus {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Status
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetNotes() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Notes
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetRepeat() *int {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Repeat
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetPrivate() *bool {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Private
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetStartedAt() *AnimeCollection_MediaListCollection_Lists_Entries_StartedAt {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.StartedAt
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetCompletedAt() *AnimeCollection_MediaListCollection_Lists_Entries_CompletedAt {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.CompletedAt
}
func (t *AnimeCollection_MediaListCollection_Lists_Entries) GetMedia() *BaseAnime {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Media
}

type AnimeCollection_MediaListCollection_Lists struct {
	Status       *MediaListStatus                                     "json:\"status,omitempty\" graphql:\"status\""
	Name         *string                                              "json:\"name,omitempty\" graphql:\"name\""
	IsCustomList *bool                                                "json:\"isCustomList,omitempty\" graphql:\"isCustomList\""
	Entries      []*AnimeCollection_MediaListCollection_Lists_Entries "json:\"entries,omitempty\" graphql:\"entries\""
}

func (t *AnimeCollection_MediaListCollection_Lists) GetStatus() *MediaListStatus {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists{}
	}
	return t.Status
}
func (t *AnimeCollection_MediaListCollection_Lists) GetName() *string {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists{}
	}
	return t.Name
}
func (t *AnimeCollection_MediaListCollection_Lists) GetIsCustomList() *bool {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists{}
	}
	return t.IsCustomList
}
func (t *AnimeCollection_MediaListCollection_Lists) GetEntries() []*AnimeCollection_MediaListCollection_Lists_Entries {
	if t == nil {
		t = &AnimeCollection_MediaListCollection_Lists{}
	}
	return t.Entries
}

type AnimeCollection_MediaListCollection struct {
	Lists []*AnimeCollection_MediaListCollection_Lists "json:\"lists,omitempty\" graphql:\"lists\""
}

func (t *AnimeCollection_MediaListCollection) GetLists() []*AnimeCollection_MediaListCollection_Lists {
	if t == nil {
		t = &AnimeCollection_MediaListCollection{}
	}
	return t.Lists
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer{}
	}
	return t.ID
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer{}
	}
	return t.Site
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Trailer{}
	}
	return t.Thumbnail
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title{}
	}
	return t.UserPreferred
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title{}
	}
	return t.Romaji
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title{}
	}
	return t.English
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title) GetNative() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Title{}
	}
	return t.Native
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage{}
	}
	return t.Large
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage{}
	}
	return t.Medium
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_CoverImage{}
	}
	return t.Color
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_StartDate{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_EndDate{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.English
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Native
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Color
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Day
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges struct {
	RelationType *MediaRelation "json:\"relationType,omitempty\" graphql:\"relationType\""
	Node         *BaseAnime     "json:\"node,omitempty\" graphql:\"node\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges) GetRelationType() *MediaRelation {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges{}
	}
	return t.RelationType
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges) GetNode() *BaseAnime {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges{}
	}
	return t.Node
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations struct {
	Edges []*AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations) GetEdges() []*AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations_Edges {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_Media_CompleteAnime_Relations{}
	}
	return t.Edges
}

type AnimeCollectionWithRelations_MediaListCollection_Lists_Entries struct {
	ID          int                                                                         "json:\"id\" graphql:\"id\""
	Score       *float64                                                                    "json:\"score,omitempty\" graphql:\"score\""
	Progress    *int                                                                        "json:\"progress,omitempty\" graphql:\"progress\""
	Status      *MediaListStatus                                                            "json:\"status,omitempty\" graphql:\"status\""
	Notes       *string                                                                     "json:\"notes,omitempty\" graphql:\"notes\""
	Repeat      *int                                                                        "json:\"repeat,omitempty\" graphql:\"repeat\""
	Private     *bool                                                                       "json:\"private,omitempty\" graphql:\"private\""
	StartedAt   *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt   "json:\"startedAt,omitempty\" graphql:\"startedAt\""
	CompletedAt *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt "json:\"completedAt,omitempty\" graphql:\"completedAt\""
	Media       *CompleteAnime                                                              "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetID() int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.ID
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetScore() *float64 {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Score
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetProgress() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Progress
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetStatus() *MediaListStatus {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Status
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetNotes() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Notes
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetRepeat() *int {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Repeat
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetPrivate() *bool {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Private
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetStartedAt() *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_StartedAt {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.StartedAt
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetCompletedAt() *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries_CompletedAt {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.CompletedAt
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists_Entries) GetMedia() *CompleteAnime {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists_Entries{}
	}
	return t.Media
}

type AnimeCollectionWithRelations_MediaListCollection_Lists struct {
	Status       *MediaListStatus                                                  "json:\"status,omitempty\" graphql:\"status\""
	Name         *string                                                           "json:\"name,omitempty\" graphql:\"name\""
	IsCustomList *bool                                                             "json:\"isCustomList,omitempty\" graphql:\"isCustomList\""
	Entries      []*AnimeCollectionWithRelations_MediaListCollection_Lists_Entries "json:\"entries,omitempty\" graphql:\"entries\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection_Lists) GetStatus() *MediaListStatus {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists{}
	}
	return t.Status
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists) GetName() *string {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists{}
	}
	return t.Name
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists) GetIsCustomList() *bool {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists{}
	}
	return t.IsCustomList
}
func (t *AnimeCollectionWithRelations_MediaListCollection_Lists) GetEntries() []*AnimeCollectionWithRelations_MediaListCollection_Lists_Entries {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection_Lists{}
	}
	return t.Entries
}

type AnimeCollectionWithRelations_MediaListCollection struct {
	Lists []*AnimeCollectionWithRelations_MediaListCollection_Lists "json:\"lists,omitempty\" graphql:\"lists\""
}

func (t *AnimeCollectionWithRelations_MediaListCollection) GetLists() []*AnimeCollectionWithRelations_MediaListCollection_Lists {
	if t == nil {
		t = &AnimeCollectionWithRelations_MediaListCollection{}
	}
	return t.Lists
}

type BaseAnimeByMalId_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *BaseAnimeByMalId_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *BaseAnimeByMalId_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type BaseAnimeByMalId_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *BaseAnimeByMalId_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *BaseAnimeByMalId_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *BaseAnimeByMalId_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_Title{}
	}
	return t.Native
}

type BaseAnimeByMalId_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *BaseAnimeByMalId_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *BaseAnimeByMalId_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *BaseAnimeByMalId_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type BaseAnimeByMalId_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *BaseAnimeByMalId_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *BaseAnimeByMalId_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type BaseAnimeByMalId_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *BaseAnimeByMalId_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *BaseAnimeByMalId_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &BaseAnimeByMalId_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type BaseAnimeById_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *BaseAnimeById_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *BaseAnimeById_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *BaseAnimeById_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type BaseAnimeById_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *BaseAnimeById_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *BaseAnimeById_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *BaseAnimeById_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *BaseAnimeById_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_Title{}
	}
	return t.Native
}

type BaseAnimeById_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *BaseAnimeById_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *BaseAnimeById_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *BaseAnimeById_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *BaseAnimeById_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type BaseAnimeById_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnimeById_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *BaseAnimeById_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *BaseAnimeById_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type BaseAnimeById_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseAnimeById_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *BaseAnimeById_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *BaseAnimeById_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type BaseAnimeById_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *BaseAnimeById_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *BaseAnimeById_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *BaseAnimeById_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &BaseAnimeById_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type SearchBaseAnimeByIds_Page_PageInfo struct {
	HasNextPage *bool "json:\"hasNextPage,omitempty\" graphql:\"hasNextPage\""
}

func (t *SearchBaseAnimeByIds_Page_PageInfo) GetHasNextPage() *bool {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_PageInfo{}
	}
	return t.HasNextPage
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_Title{}
	}
	return t.Native
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type SearchBaseAnimeByIds_Page struct {
	PageInfo *SearchBaseAnimeByIds_Page_PageInfo "json:\"pageInfo,omitempty\" graphql:\"pageInfo\""
	Media    []*BaseAnime                        "json:\"media,omitempty\" graphql:\"media\""
}

func (t *SearchBaseAnimeByIds_Page) GetPageInfo() *SearchBaseAnimeByIds_Page_PageInfo {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page{}
	}
	return t.PageInfo
}
func (t *SearchBaseAnimeByIds_Page) GetMedia() []*BaseAnime {
	if t == nil {
		t = &SearchBaseAnimeByIds_Page{}
	}
	return t.Media
}

type CompleteAnimeById_Media_CompleteAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Trailer) GetID() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Trailer{}
	}
	return t.ID
}
func (t *CompleteAnimeById_Media_CompleteAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Trailer{}
	}
	return t.Site
}
func (t *CompleteAnimeById_Media_CompleteAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Trailer{}
	}
	return t.Thumbnail
}

type CompleteAnimeById_Media_CompleteAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Title{}
	}
	return t.UserPreferred
}
func (t *CompleteAnimeById_Media_CompleteAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Title{}
	}
	return t.Romaji
}
func (t *CompleteAnimeById_Media_CompleteAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Title{}
	}
	return t.English
}
func (t *CompleteAnimeById_Media_CompleteAnime_Title) GetNative() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Title{}
	}
	return t.Native
}

type CompleteAnimeById_Media_CompleteAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *CompleteAnimeById_Media_CompleteAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_CoverImage{}
	}
	return t.Large
}
func (t *CompleteAnimeById_Media_CompleteAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_CoverImage{}
	}
	return t.Medium
}
func (t *CompleteAnimeById_Media_CompleteAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_CoverImage{}
	}
	return t.Color
}

type CompleteAnimeById_Media_CompleteAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_StartDate{}
	}
	return t.Year
}
func (t *CompleteAnimeById_Media_CompleteAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_StartDate{}
	}
	return t.Month
}
func (t *CompleteAnimeById_Media_CompleteAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_StartDate{}
	}
	return t.Day
}

type CompleteAnimeById_Media_CompleteAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_EndDate{}
	}
	return t.Year
}
func (t *CompleteAnimeById_Media_CompleteAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_EndDate{}
	}
	return t.Month
}
func (t *CompleteAnimeById_Media_CompleteAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_EndDate{}
	}
	return t.Day
}

type CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.English
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Native
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Color
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Day
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Day
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type CompleteAnimeById_Media_CompleteAnime_Relations_Edges struct {
	RelationType *MediaRelation "json:\"relationType,omitempty\" graphql:\"relationType\""
	Node         *BaseAnime     "json:\"node,omitempty\" graphql:\"node\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges) GetRelationType() *MediaRelation {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges{}
	}
	return t.RelationType
}
func (t *CompleteAnimeById_Media_CompleteAnime_Relations_Edges) GetNode() *BaseAnime {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations_Edges{}
	}
	return t.Node
}

type CompleteAnimeById_Media_CompleteAnime_Relations struct {
	Edges []*CompleteAnimeById_Media_CompleteAnime_Relations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *CompleteAnimeById_Media_CompleteAnime_Relations) GetEdges() []*CompleteAnimeById_Media_CompleteAnime_Relations_Edges {
	if t == nil {
		t = &CompleteAnimeById_Media_CompleteAnime_Relations{}
	}
	return t.Edges
}

type AnimeDetailsById_Media_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeDetailsById_Media_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Trailer{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Trailer{}
	}
	return t.Site
}
func (t *AnimeDetailsById_Media_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Trailer{}
	}
	return t.Thumbnail
}

type AnimeDetailsById_Media_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_StartDate{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_StartDate{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_StartDate{}
	}
	return t.Day
}

type AnimeDetailsById_Media_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_EndDate) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_EndDate{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_EndDate) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_EndDate{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_EndDate) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_EndDate{}
	}
	return t.Day
}

type AnimeDetailsById_Media_Studios_Nodes struct {
	Name string "json:\"name\" graphql:\"name\""
	ID   int    "json:\"id\" graphql:\"id\""
}

func (t *AnimeDetailsById_Media_Studios_Nodes) GetName() string {
	if t == nil {
		t = &AnimeDetailsById_Media_Studios_Nodes{}
	}
	return t.Name
}
func (t *AnimeDetailsById_Media_Studios_Nodes) GetID() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Studios_Nodes{}
	}
	return t.ID
}

type AnimeDetailsById_Media_Studios struct {
	Nodes []*AnimeDetailsById_Media_Studios_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeDetailsById_Media_Studios) GetNodes() []*AnimeDetailsById_Media_Studios_Nodes {
	if t == nil {
		t = &AnimeDetailsById_Media_Studios{}
	}
	return t.Nodes
}

type AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Day
}

type AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name struct {
	Full        *string   "json:\"full,omitempty\" graphql:\"full\""
	Native      *string   "json:\"native,omitempty\" graphql:\"native\""
	Alternative []*string "json:\"alternative,omitempty\" graphql:\"alternative\""
}

func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetFull() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Full
}
func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetNative() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Native
}
func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetAlternative() []*string {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Alternative
}

type AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image struct {
	Large *string "json:\"large,omitempty\" graphql:\"large\""
}

func (t *AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image) GetLarge() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image{}
	}
	return t.Large
}

type AnimeDetailsById_Media_Characters_Edges struct {
	ID   *int           "json:\"id,omitempty\" graphql:\"id\""
	Role *CharacterRole "json:\"role,omitempty\" graphql:\"role\""
	Name *string        "json:\"name,omitempty\" graphql:\"name\""
	Node *BaseCharacter "json:\"node,omitempty\" graphql:\"node\""
}

func (t *AnimeDetailsById_Media_Characters_Edges) GetID() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media_Characters_Edges) GetRole() *CharacterRole {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges{}
	}
	return t.Role
}
func (t *AnimeDetailsById_Media_Characters_Edges) GetName() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges{}
	}
	return t.Name
}
func (t *AnimeDetailsById_Media_Characters_Edges) GetNode() *BaseCharacter {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters_Edges{}
	}
	return t.Node
}

type AnimeDetailsById_Media_Characters struct {
	Edges []*AnimeDetailsById_Media_Characters_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *AnimeDetailsById_Media_Characters) GetEdges() []*AnimeDetailsById_Media_Characters_Edges {
	if t == nil {
		t = &AnimeDetailsById_Media_Characters{}
	}
	return t.Edges
}

type AnimeDetailsById_Media_Staff_Edges_Node_Name struct {
	Full *string "json:\"full,omitempty\" graphql:\"full\""
}

func (t *AnimeDetailsById_Media_Staff_Edges_Node_Name) GetFull() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff_Edges_Node_Name{}
	}
	return t.Full
}

type AnimeDetailsById_Media_Staff_Edges_Node struct {
	Name *AnimeDetailsById_Media_Staff_Edges_Node_Name "json:\"name,omitempty\" graphql:\"name\""
	ID   int                                           "json:\"id\" graphql:\"id\""
}

func (t *AnimeDetailsById_Media_Staff_Edges_Node) GetName() *AnimeDetailsById_Media_Staff_Edges_Node_Name {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff_Edges_Node{}
	}
	return t.Name
}
func (t *AnimeDetailsById_Media_Staff_Edges_Node) GetID() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff_Edges_Node{}
	}
	return t.ID
}

type AnimeDetailsById_Media_Staff_Edges struct {
	Role *string                                  "json:\"role,omitempty\" graphql:\"role\""
	Node *AnimeDetailsById_Media_Staff_Edges_Node "json:\"node,omitempty\" graphql:\"node\""
}

func (t *AnimeDetailsById_Media_Staff_Edges) GetRole() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff_Edges{}
	}
	return t.Role
}
func (t *AnimeDetailsById_Media_Staff_Edges) GetNode() *AnimeDetailsById_Media_Staff_Edges_Node {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff_Edges{}
	}
	return t.Node
}

type AnimeDetailsById_Media_Staff struct {
	Edges []*AnimeDetailsById_Media_Staff_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *AnimeDetailsById_Media_Staff) GetEdges() []*AnimeDetailsById_Media_Staff_Edges {
	if t == nil {
		t = &AnimeDetailsById_Media_Staff{}
	}
	return t.Edges
}

type AnimeDetailsById_Media_Rankings struct {
	Context string        "json:\"context\" graphql:\"context\""
	Type    MediaRankType "json:\"type\" graphql:\"type\""
	Rank    int           "json:\"rank\" graphql:\"rank\""
	Year    *int          "json:\"year,omitempty\" graphql:\"year\""
	Format  MediaFormat   "json:\"format\" graphql:\"format\""
	AllTime *bool         "json:\"allTime,omitempty\" graphql:\"allTime\""
	Season  *MediaSeason  "json:\"season,omitempty\" graphql:\"season\""
}

func (t *AnimeDetailsById_Media_Rankings) GetContext() string {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return t.Context
}
func (t *AnimeDetailsById_Media_Rankings) GetType() *MediaRankType {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return &t.Type
}
func (t *AnimeDetailsById_Media_Rankings) GetRank() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return t.Rank
}
func (t *AnimeDetailsById_Media_Rankings) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_Rankings) GetFormat() *MediaFormat {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return &t.Format
}
func (t *AnimeDetailsById_Media_Rankings) GetAllTime() *bool {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return t.AllTime
}
func (t *AnimeDetailsById_Media_Rankings) GetSeason() *MediaSeason {
	if t == nil {
		t = &AnimeDetailsById_Media_Rankings{}
	}
	return t.Season
}

type AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer{}
	}
	return t.Site
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer{}
	}
	return t.Thumbnail
}

type AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Day
}

type AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetLarge() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Large
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetMedium() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Medium
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetColor() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Color
}

type AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title struct {
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetRomaji() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.Romaji
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetEnglish() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.English
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetNative() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.Native
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetUserPreferred() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.UserPreferred
}

type AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation struct {
	ID          int                                                                               "json:\"id\" graphql:\"id\""
	IDMal       *int                                                                              "json:\"idMal,omitempty\" graphql:\"idMal\""
	SiteURL     *string                                                                           "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	Status      *MediaStatus                                                                      "json:\"status,omitempty\" graphql:\"status\""
	IsAdult     *bool                                                                             "json:\"isAdult,omitempty\" graphql:\"isAdult\""
	Season      *MediaSeason                                                                      "json:\"season,omitempty\" graphql:\"season\""
	Type        *MediaType                                                                        "json:\"type,omitempty\" graphql:\"type\""
	Format      *MediaFormat                                                                      "json:\"format,omitempty\" graphql:\"format\""
	MeanScore   *int                                                                              "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description *string                                                                           "json:\"description,omitempty\" graphql:\"description\""
	Episodes    *int                                                                              "json:\"episodes,omitempty\" graphql:\"episodes\""
	Trailer     *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer    "json:\"trailer,omitempty\" graphql:\"trailer\""
	StartDate   *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate  "json:\"startDate,omitempty\" graphql:\"startDate\""
	CoverImage  *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage "json:\"coverImage,omitempty\" graphql:\"coverImage\""
	BannerImage *string                                                                           "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	Title       *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title      "json:\"title,omitempty\" graphql:\"title\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetID() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetIDMal() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.IDMal
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetSiteURL() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.SiteURL
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetStatus() *MediaStatus {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Status
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetIsAdult() *bool {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.IsAdult
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetSeason() *MediaSeason {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Season
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetType() *MediaType {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Type
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetFormat() *MediaFormat {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Format
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetMeanScore() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.MeanScore
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetDescription() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Description
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetEpisodes() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Episodes
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetTrailer() *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Trailer {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Trailer
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetStartDate() *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.StartDate
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetCoverImage() *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.CoverImage
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetBannerImage() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.BannerImage
}
func (t *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetTitle() *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Title
}

type AnimeDetailsById_Media_Recommendations_Edges_Node struct {
	MediaRecommendation *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation "json:\"mediaRecommendation,omitempty\" graphql:\"mediaRecommendation\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges_Node) GetMediaRecommendation() *AnimeDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges_Node{}
	}
	return t.MediaRecommendation
}

type AnimeDetailsById_Media_Recommendations_Edges struct {
	Node *AnimeDetailsById_Media_Recommendations_Edges_Node "json:\"node,omitempty\" graphql:\"node\""
}

func (t *AnimeDetailsById_Media_Recommendations_Edges) GetNode() *AnimeDetailsById_Media_Recommendations_Edges_Node {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations_Edges{}
	}
	return t.Node
}

type AnimeDetailsById_Media_Recommendations struct {
	Edges []*AnimeDetailsById_Media_Recommendations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *AnimeDetailsById_Media_Recommendations) GetEdges() []*AnimeDetailsById_Media_Recommendations_Edges {
	if t == nil {
		t = &AnimeDetailsById_Media_Recommendations{}
	}
	return t.Edges
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.English
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_Title{}
	}
	return t.Native
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_CoverImage{}
	}
	return t.Color
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_StartDate{}
	}
	return t.Day
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_EndDate{}
	}
	return t.Day
}

type AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges_Node_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type AnimeDetailsById_Media_Relations_Edges struct {
	RelationType *MediaRelation "json:\"relationType,omitempty\" graphql:\"relationType\""
	Node         *BaseAnime     "json:\"node,omitempty\" graphql:\"node\""
}

func (t *AnimeDetailsById_Media_Relations_Edges) GetRelationType() *MediaRelation {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges{}
	}
	return t.RelationType
}
func (t *AnimeDetailsById_Media_Relations_Edges) GetNode() *BaseAnime {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations_Edges{}
	}
	return t.Node
}

type AnimeDetailsById_Media_Relations struct {
	Edges []*AnimeDetailsById_Media_Relations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *AnimeDetailsById_Media_Relations) GetEdges() []*AnimeDetailsById_Media_Relations_Edges {
	if t == nil {
		t = &AnimeDetailsById_Media_Relations{}
	}
	return t.Edges
}

type AnimeDetailsById_Media struct {
	SiteURL         *string                                 "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	ID              int                                     "json:\"id\" graphql:\"id\""
	Duration        *int                                    "json:\"duration,omitempty\" graphql:\"duration\""
	Genres          []*string                               "json:\"genres,omitempty\" graphql:\"genres\""
	AverageScore    *int                                    "json:\"averageScore,omitempty\" graphql:\"averageScore\""
	Popularity      *int                                    "json:\"popularity,omitempty\" graphql:\"popularity\""
	MeanScore       *int                                    "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description     *string                                 "json:\"description,omitempty\" graphql:\"description\""
	Trailer         *AnimeDetailsById_Media_Trailer         "json:\"trailer,omitempty\" graphql:\"trailer\""
	StartDate       *AnimeDetailsById_Media_StartDate       "json:\"startDate,omitempty\" graphql:\"startDate\""
	EndDate         *AnimeDetailsById_Media_EndDate         "json:\"endDate,omitempty\" graphql:\"endDate\""
	Studios         *AnimeDetailsById_Media_Studios         "json:\"studios,omitempty\" graphql:\"studios\""
	Characters      *AnimeDetailsById_Media_Characters      "json:\"characters,omitempty\" graphql:\"characters\""
	Staff           *AnimeDetailsById_Media_Staff           "json:\"staff,omitempty\" graphql:\"staff\""
	Rankings        []*AnimeDetailsById_Media_Rankings      "json:\"rankings,omitempty\" graphql:\"rankings\""
	Recommendations *AnimeDetailsById_Media_Recommendations "json:\"recommendations,omitempty\" graphql:\"recommendations\""
	Relations       *AnimeDetailsById_Media_Relations       "json:\"relations,omitempty\" graphql:\"relations\""
}

func (t *AnimeDetailsById_Media) GetSiteURL() *string {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.SiteURL
}
func (t *AnimeDetailsById_Media) GetID() int {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.ID
}
func (t *AnimeDetailsById_Media) GetDuration() *int {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Duration
}
func (t *AnimeDetailsById_Media) GetGenres() []*string {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Genres
}
func (t *AnimeDetailsById_Media) GetAverageScore() *int {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.AverageScore
}
func (t *AnimeDetailsById_Media) GetPopularity() *int {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Popularity
}
func (t *AnimeDetailsById_Media) GetMeanScore() *int {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.MeanScore
}
func (t *AnimeDetailsById_Media) GetDescription() *string {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Description
}
func (t *AnimeDetailsById_Media) GetTrailer() *AnimeDetailsById_Media_Trailer {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Trailer
}
func (t *AnimeDetailsById_Media) GetStartDate() *AnimeDetailsById_Media_StartDate {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.StartDate
}
func (t *AnimeDetailsById_Media) GetEndDate() *AnimeDetailsById_Media_EndDate {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.EndDate
}
func (t *AnimeDetailsById_Media) GetStudios() *AnimeDetailsById_Media_Studios {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Studios
}
func (t *AnimeDetailsById_Media) GetCharacters() *AnimeDetailsById_Media_Characters {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Characters
}
func (t *AnimeDetailsById_Media) GetStaff() *AnimeDetailsById_Media_Staff {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Staff
}
func (t *AnimeDetailsById_Media) GetRankings() []*AnimeDetailsById_Media_Rankings {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Rankings
}
func (t *AnimeDetailsById_Media) GetRecommendations() *AnimeDetailsById_Media_Recommendations {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Recommendations
}
func (t *AnimeDetailsById_Media) GetRelations() *AnimeDetailsById_Media_Relations {
	if t == nil {
		t = &AnimeDetailsById_Media{}
	}
	return t.Relations
}

type ListAnime_Page_PageInfo struct {
	HasNextPage *bool "json:\"hasNextPage,omitempty\" graphql:\"hasNextPage\""
	Total       *int  "json:\"total,omitempty\" graphql:\"total\""
	PerPage     *int  "json:\"perPage,omitempty\" graphql:\"perPage\""
	CurrentPage *int  "json:\"currentPage,omitempty\" graphql:\"currentPage\""
	LastPage    *int  "json:\"lastPage,omitempty\" graphql:\"lastPage\""
}

func (t *ListAnime_Page_PageInfo) GetHasNextPage() *bool {
	if t == nil {
		t = &ListAnime_Page_PageInfo{}
	}
	return t.HasNextPage
}
func (t *ListAnime_Page_PageInfo) GetTotal() *int {
	if t == nil {
		t = &ListAnime_Page_PageInfo{}
	}
	return t.Total
}
func (t *ListAnime_Page_PageInfo) GetPerPage() *int {
	if t == nil {
		t = &ListAnime_Page_PageInfo{}
	}
	return t.PerPage
}
func (t *ListAnime_Page_PageInfo) GetCurrentPage() *int {
	if t == nil {
		t = &ListAnime_Page_PageInfo{}
	}
	return t.CurrentPage
}
func (t *ListAnime_Page_PageInfo) GetLastPage() *int {
	if t == nil {
		t = &ListAnime_Page_PageInfo{}
	}
	return t.LastPage
}

type ListAnime_Page_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *ListAnime_Page_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *ListAnime_Page_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *ListAnime_Page_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type ListAnime_Page_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *ListAnime_Page_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *ListAnime_Page_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *ListAnime_Page_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *ListAnime_Page_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_Title{}
	}
	return t.Native
}

type ListAnime_Page_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *ListAnime_Page_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *ListAnime_Page_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *ListAnime_Page_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *ListAnime_Page_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type ListAnime_Page_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListAnime_Page_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *ListAnime_Page_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *ListAnime_Page_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type ListAnime_Page_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListAnime_Page_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *ListAnime_Page_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *ListAnime_Page_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type ListAnime_Page_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *ListAnime_Page_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *ListAnime_Page_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *ListAnime_Page_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &ListAnime_Page_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type ListAnime_Page struct {
	PageInfo *ListAnime_Page_PageInfo "json:\"pageInfo,omitempty\" graphql:\"pageInfo\""
	Media    []*BaseAnime             "json:\"media,omitempty\" graphql:\"media\""
}

func (t *ListAnime_Page) GetPageInfo() *ListAnime_Page_PageInfo {
	if t == nil {
		t = &ListAnime_Page{}
	}
	return t.PageInfo
}
func (t *ListAnime_Page) GetMedia() []*BaseAnime {
	if t == nil {
		t = &ListAnime_Page{}
	}
	return t.Media
}

type ListRecentAnime_Page_PageInfo struct {
	HasNextPage *bool "json:\"hasNextPage,omitempty\" graphql:\"hasNextPage\""
	Total       *int  "json:\"total,omitempty\" graphql:\"total\""
	PerPage     *int  "json:\"perPage,omitempty\" graphql:\"perPage\""
	CurrentPage *int  "json:\"currentPage,omitempty\" graphql:\"currentPage\""
	LastPage    *int  "json:\"lastPage,omitempty\" graphql:\"lastPage\""
}

func (t *ListRecentAnime_Page_PageInfo) GetHasNextPage() *bool {
	if t == nil {
		t = &ListRecentAnime_Page_PageInfo{}
	}
	return t.HasNextPage
}
func (t *ListRecentAnime_Page_PageInfo) GetTotal() *int {
	if t == nil {
		t = &ListRecentAnime_Page_PageInfo{}
	}
	return t.Total
}
func (t *ListRecentAnime_Page_PageInfo) GetPerPage() *int {
	if t == nil {
		t = &ListRecentAnime_Page_PageInfo{}
	}
	return t.PerPage
}
func (t *ListRecentAnime_Page_PageInfo) GetCurrentPage() *int {
	if t == nil {
		t = &ListRecentAnime_Page_PageInfo{}
	}
	return t.CurrentPage
}
func (t *ListRecentAnime_Page_PageInfo) GetLastPage() *int {
	if t == nil {
		t = &ListRecentAnime_Page_PageInfo{}
	}
	return t.LastPage
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title{}
	}
	return t.English
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_Title{}
	}
	return t.Native
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_CoverImage{}
	}
	return t.Color
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_StartDate{}
	}
	return t.Day
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_EndDate{}
	}
	return t.Day
}

type ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules_Media_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type ListRecentAnime_Page_AiringSchedules struct {
	ID              int        "json:\"id\" graphql:\"id\""
	AiringAt        int        "json:\"airingAt\" graphql:\"airingAt\""
	Episode         int        "json:\"episode\" graphql:\"episode\""
	TimeUntilAiring int        "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Media           *BaseAnime "json:\"media,omitempty\" graphql:\"media\""
}

func (t *ListRecentAnime_Page_AiringSchedules) GetID() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules{}
	}
	return t.ID
}
func (t *ListRecentAnime_Page_AiringSchedules) GetAiringAt() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules{}
	}
	return t.AiringAt
}
func (t *ListRecentAnime_Page_AiringSchedules) GetEpisode() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules{}
	}
	return t.Episode
}
func (t *ListRecentAnime_Page_AiringSchedules) GetTimeUntilAiring() int {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules{}
	}
	return t.TimeUntilAiring
}
func (t *ListRecentAnime_Page_AiringSchedules) GetMedia() *BaseAnime {
	if t == nil {
		t = &ListRecentAnime_Page_AiringSchedules{}
	}
	return t.Media
}

type ListRecentAnime_Page struct {
	PageInfo        *ListRecentAnime_Page_PageInfo          "json:\"pageInfo,omitempty\" graphql:\"pageInfo\""
	AiringSchedules []*ListRecentAnime_Page_AiringSchedules "json:\"airingSchedules,omitempty\" graphql:\"airingSchedules\""
}

func (t *ListRecentAnime_Page) GetPageInfo() *ListRecentAnime_Page_PageInfo {
	if t == nil {
		t = &ListRecentAnime_Page{}
	}
	return t.PageInfo
}
func (t *ListRecentAnime_Page) GetAiringSchedules() []*ListRecentAnime_Page_AiringSchedules {
	if t == nil {
		t = &ListRecentAnime_Page{}
	}
	return t.AiringSchedules
}

type AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Ongoing struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringSchedule_Ongoing) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringSchedule_Ongoing{}
	}
	return t.Media
}

type AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_OngoingNext struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringSchedule_OngoingNext) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringSchedule_OngoingNext{}
	}
	return t.Media
}

type AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Upcoming struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringSchedule_Upcoming) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringSchedule_Upcoming{}
	}
	return t.Media
}

type AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_UpcomingNext struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringSchedule_UpcomingNext) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringSchedule_UpcomingNext{}
	}
	return t.Media
}

type AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringSchedule_Preceding struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringSchedule_Preceding) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringSchedule_Preceding{}
	}
	return t.Media
}

type AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes{}
	}
	return t.Episode
}

type AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous struct {
	Nodes []*AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous) GetNodes() []*AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous_Nodes {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Previous{}
	}
	return t.Nodes
}

type AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes) GetAiringAt() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.AiringAt
}
func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes) GetTimeUntilAiring() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.TimeUntilAiring
}
func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes) GetEpisode() int {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes{}
	}
	return t.Episode
}

type AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming struct {
	Nodes []*AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming) GetNodes() []*AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming_Nodes {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page_Media_AnimeSchedule_Upcoming{}
	}
	return t.Nodes
}

type AnimeAiringScheduleRaw_Page struct {
	Media []*AnimeSchedule "json:\"media,omitempty\" graphql:\"media\""
}

func (t *AnimeAiringScheduleRaw_Page) GetMedia() []*AnimeSchedule {
	if t == nil {
		t = &AnimeAiringScheduleRaw_Page{}
	}
	return t.Media
}

type UpdateMediaListEntry_SaveMediaListEntry struct {
	ID int "json:\"id\" graphql:\"id\""
}

func (t *UpdateMediaListEntry_SaveMediaListEntry) GetID() int {
	if t == nil {
		t = &UpdateMediaListEntry_SaveMediaListEntry{}
	}
	return t.ID
}

type UpdateMediaListEntryProgress_SaveMediaListEntry struct {
	ID int "json:\"id\" graphql:\"id\""
}

func (t *UpdateMediaListEntryProgress_SaveMediaListEntry) GetID() int {
	if t == nil {
		t = &UpdateMediaListEntryProgress_SaveMediaListEntry{}
	}
	return t.ID
}

type DeleteEntry_DeleteMediaListEntry struct {
	Deleted *bool "json:\"deleted,omitempty\" graphql:\"deleted\""
}

func (t *DeleteEntry_DeleteMediaListEntry) GetDeleted() *bool {
	if t == nil {
		t = &DeleteEntry_DeleteMediaListEntry{}
	}
	return t.Deleted
}

type UpdateMediaListEntryRepeat_SaveMediaListEntry struct {
	ID int "json:\"id\" graphql:\"id\""
}

func (t *UpdateMediaListEntryRepeat_SaveMediaListEntry) GetID() int {
	if t == nil {
		t = &UpdateMediaListEntryRepeat_SaveMediaListEntry{}
	}
	return t.ID
}

type MangaCollection_MediaListCollection_Lists_Entries_StartedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_StartedAt) GetYear() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Year
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_StartedAt) GetMonth() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Month
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_StartedAt) GetDay() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_StartedAt{}
	}
	return t.Day
}

type MangaCollection_MediaListCollection_Lists_Entries_CompletedAt struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_CompletedAt) GetYear() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Year
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_CompletedAt) GetMonth() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Month
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_CompletedAt) GetDay() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_CompletedAt{}
	}
	return t.Day
}

type MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title{}
	}
	return t.Romaji
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title{}
	}
	return t.English
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_Title{}
	}
	return t.Native
}

type MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_CoverImage{}
	}
	return t.Color
}

type MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate{}
	}
	return t.Year
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate{}
	}
	return t.Month
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_StartDate{}
	}
	return t.Day
}

type MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate{}
	}
	return t.Year
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate{}
	}
	return t.Month
}
func (t *MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries_Media_BaseManga_EndDate{}
	}
	return t.Day
}

type MangaCollection_MediaListCollection_Lists_Entries struct {
	ID          int                                                            "json:\"id\" graphql:\"id\""
	Score       *float64                                                       "json:\"score,omitempty\" graphql:\"score\""
	Progress    *int                                                           "json:\"progress,omitempty\" graphql:\"progress\""
	Status      *MediaListStatus                                               "json:\"status,omitempty\" graphql:\"status\""
	Notes       *string                                                        "json:\"notes,omitempty\" graphql:\"notes\""
	Repeat      *int                                                           "json:\"repeat,omitempty\" graphql:\"repeat\""
	Private     *bool                                                          "json:\"private,omitempty\" graphql:\"private\""
	StartedAt   *MangaCollection_MediaListCollection_Lists_Entries_StartedAt   "json:\"startedAt,omitempty\" graphql:\"startedAt\""
	CompletedAt *MangaCollection_MediaListCollection_Lists_Entries_CompletedAt "json:\"completedAt,omitempty\" graphql:\"completedAt\""
	Media       *BaseManga                                                     "json:\"media,omitempty\" graphql:\"media\""
}

func (t *MangaCollection_MediaListCollection_Lists_Entries) GetID() int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.ID
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetScore() *float64 {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Score
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetProgress() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Progress
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetStatus() *MediaListStatus {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Status
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetNotes() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Notes
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetRepeat() *int {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Repeat
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetPrivate() *bool {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Private
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetStartedAt() *MangaCollection_MediaListCollection_Lists_Entries_StartedAt {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.StartedAt
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetCompletedAt() *MangaCollection_MediaListCollection_Lists_Entries_CompletedAt {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.CompletedAt
}
func (t *MangaCollection_MediaListCollection_Lists_Entries) GetMedia() *BaseManga {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists_Entries{}
	}
	return t.Media
}

type MangaCollection_MediaListCollection_Lists struct {
	Status       *MediaListStatus                                     "json:\"status,omitempty\" graphql:\"status\""
	Name         *string                                              "json:\"name,omitempty\" graphql:\"name\""
	IsCustomList *bool                                                "json:\"isCustomList,omitempty\" graphql:\"isCustomList\""
	Entries      []*MangaCollection_MediaListCollection_Lists_Entries "json:\"entries,omitempty\" graphql:\"entries\""
}

func (t *MangaCollection_MediaListCollection_Lists) GetStatus() *MediaListStatus {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists{}
	}
	return t.Status
}
func (t *MangaCollection_MediaListCollection_Lists) GetName() *string {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists{}
	}
	return t.Name
}
func (t *MangaCollection_MediaListCollection_Lists) GetIsCustomList() *bool {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists{}
	}
	return t.IsCustomList
}
func (t *MangaCollection_MediaListCollection_Lists) GetEntries() []*MangaCollection_MediaListCollection_Lists_Entries {
	if t == nil {
		t = &MangaCollection_MediaListCollection_Lists{}
	}
	return t.Entries
}

type MangaCollection_MediaListCollection struct {
	Lists []*MangaCollection_MediaListCollection_Lists "json:\"lists,omitempty\" graphql:\"lists\""
}

func (t *MangaCollection_MediaListCollection) GetLists() []*MangaCollection_MediaListCollection_Lists {
	if t == nil {
		t = &MangaCollection_MediaListCollection{}
	}
	return t.Lists
}

type SearchBaseManga_Page_PageInfo struct {
	HasNextPage *bool "json:\"hasNextPage,omitempty\" graphql:\"hasNextPage\""
}

func (t *SearchBaseManga_Page_PageInfo) GetHasNextPage() *bool {
	if t == nil {
		t = &SearchBaseManga_Page_PageInfo{}
	}
	return t.HasNextPage
}

type SearchBaseManga_Page_Media_BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *SearchBaseManga_Page_Media_BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *SearchBaseManga_Page_Media_BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_Title{}
	}
	return t.Romaji
}
func (t *SearchBaseManga_Page_Media_BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_Title{}
	}
	return t.English
}
func (t *SearchBaseManga_Page_Media_BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_Title{}
	}
	return t.Native
}

type SearchBaseManga_Page_Media_BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *SearchBaseManga_Page_Media_BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *SearchBaseManga_Page_Media_BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *SearchBaseManga_Page_Media_BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *SearchBaseManga_Page_Media_BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Color
}

type SearchBaseManga_Page_Media_BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *SearchBaseManga_Page_Media_BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Year
}
func (t *SearchBaseManga_Page_Media_BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Month
}
func (t *SearchBaseManga_Page_Media_BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Day
}

type SearchBaseManga_Page_Media_BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *SearchBaseManga_Page_Media_BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Year
}
func (t *SearchBaseManga_Page_Media_BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Month
}
func (t *SearchBaseManga_Page_Media_BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &SearchBaseManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Day
}

type SearchBaseManga_Page struct {
	PageInfo *SearchBaseManga_Page_PageInfo "json:\"pageInfo,omitempty\" graphql:\"pageInfo\""
	Media    []*BaseManga                   "json:\"media,omitempty\" graphql:\"media\""
}

func (t *SearchBaseManga_Page) GetPageInfo() *SearchBaseManga_Page_PageInfo {
	if t == nil {
		t = &SearchBaseManga_Page{}
	}
	return t.PageInfo
}
func (t *SearchBaseManga_Page) GetMedia() []*BaseManga {
	if t == nil {
		t = &SearchBaseManga_Page{}
	}
	return t.Media
}

type BaseMangaById_Media_BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *BaseMangaById_Media_BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *BaseMangaById_Media_BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_Title{}
	}
	return t.Romaji
}
func (t *BaseMangaById_Media_BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_Title{}
	}
	return t.English
}
func (t *BaseMangaById_Media_BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_Title{}
	}
	return t.Native
}

type BaseMangaById_Media_BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *BaseMangaById_Media_BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *BaseMangaById_Media_BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *BaseMangaById_Media_BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *BaseMangaById_Media_BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_CoverImage{}
	}
	return t.Color
}

type BaseMangaById_Media_BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseMangaById_Media_BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_StartDate{}
	}
	return t.Year
}
func (t *BaseMangaById_Media_BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_StartDate{}
	}
	return t.Month
}
func (t *BaseMangaById_Media_BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_StartDate{}
	}
	return t.Day
}

type BaseMangaById_Media_BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *BaseMangaById_Media_BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_EndDate{}
	}
	return t.Year
}
func (t *BaseMangaById_Media_BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_EndDate{}
	}
	return t.Month
}
func (t *BaseMangaById_Media_BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &BaseMangaById_Media_BaseManga_EndDate{}
	}
	return t.Day
}

type MangaDetailsById_Media_Rankings struct {
	Context string        "json:\"context\" graphql:\"context\""
	Type    MediaRankType "json:\"type\" graphql:\"type\""
	Rank    int           "json:\"rank\" graphql:\"rank\""
	Year    *int          "json:\"year,omitempty\" graphql:\"year\""
	Format  MediaFormat   "json:\"format\" graphql:\"format\""
	AllTime *bool         "json:\"allTime,omitempty\" graphql:\"allTime\""
	Season  *MediaSeason  "json:\"season,omitempty\" graphql:\"season\""
}

func (t *MangaDetailsById_Media_Rankings) GetContext() string {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return t.Context
}
func (t *MangaDetailsById_Media_Rankings) GetType() *MediaRankType {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return &t.Type
}
func (t *MangaDetailsById_Media_Rankings) GetRank() int {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return t.Rank
}
func (t *MangaDetailsById_Media_Rankings) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Rankings) GetFormat() *MediaFormat {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return &t.Format
}
func (t *MangaDetailsById_Media_Rankings) GetAllTime() *bool {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return t.AllTime
}
func (t *MangaDetailsById_Media_Rankings) GetSeason() *MediaSeason {
	if t == nil {
		t = &MangaDetailsById_Media_Rankings{}
	}
	return t.Season
}

type MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetMonth() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Month
}
func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth) GetDay() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_DateOfBirth{}
	}
	return t.Day
}

type MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name struct {
	Full        *string   "json:\"full,omitempty\" graphql:\"full\""
	Native      *string   "json:\"native,omitempty\" graphql:\"native\""
	Alternative []*string "json:\"alternative,omitempty\" graphql:\"alternative\""
}

func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetFull() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Full
}
func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetNative() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Native
}
func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name) GetAlternative() []*string {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Name{}
	}
	return t.Alternative
}

type MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image struct {
	Large *string "json:\"large,omitempty\" graphql:\"large\""
}

func (t *MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image) GetLarge() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges_Node_BaseCharacter_Image{}
	}
	return t.Large
}

type MangaDetailsById_Media_Characters_Edges struct {
	ID   *int           "json:\"id,omitempty\" graphql:\"id\""
	Role *CharacterRole "json:\"role,omitempty\" graphql:\"role\""
	Name *string        "json:\"name,omitempty\" graphql:\"name\""
	Node *BaseCharacter "json:\"node,omitempty\" graphql:\"node\""
}

func (t *MangaDetailsById_Media_Characters_Edges) GetID() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges{}
	}
	return t.ID
}
func (t *MangaDetailsById_Media_Characters_Edges) GetRole() *CharacterRole {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges{}
	}
	return t.Role
}
func (t *MangaDetailsById_Media_Characters_Edges) GetName() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges{}
	}
	return t.Name
}
func (t *MangaDetailsById_Media_Characters_Edges) GetNode() *BaseCharacter {
	if t == nil {
		t = &MangaDetailsById_Media_Characters_Edges{}
	}
	return t.Node
}

type MangaDetailsById_Media_Characters struct {
	Edges []*MangaDetailsById_Media_Characters_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *MangaDetailsById_Media_Characters) GetEdges() []*MangaDetailsById_Media_Characters_Edges {
	if t == nil {
		t = &MangaDetailsById_Media_Characters{}
	}
	return t.Edges
}

type MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetUserPreferred() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.UserPreferred
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetRomaji() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.Romaji
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetEnglish() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.English
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title) GetNative() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title{}
	}
	return t.Native
}

type MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetLarge() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Large
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetMedium() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Medium
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage) GetColor() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage{}
	}
	return t.Color
}

type MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetMonth() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Month
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate) GetDay() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate{}
	}
	return t.Day
}

type MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate) GetMonth() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate{}
	}
	return t.Month
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate) GetDay() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate{}
	}
	return t.Day
}

type MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation struct {
	ID              int                                                                               "json:\"id\" graphql:\"id\""
	IDMal           *int                                                                              "json:\"idMal,omitempty\" graphql:\"idMal\""
	SiteURL         *string                                                                           "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	Status          *MediaStatus                                                                      "json:\"status,omitempty\" graphql:\"status\""
	Season          *MediaSeason                                                                      "json:\"season,omitempty\" graphql:\"season\""
	Type            *MediaType                                                                        "json:\"type,omitempty\" graphql:\"type\""
	Format          *MediaFormat                                                                      "json:\"format,omitempty\" graphql:\"format\""
	BannerImage     *string                                                                           "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	Chapters        *int                                                                              "json:\"chapters,omitempty\" graphql:\"chapters\""
	Volumes         *int                                                                              "json:\"volumes,omitempty\" graphql:\"volumes\""
	Synonyms        []*string                                                                         "json:\"synonyms,omitempty\" graphql:\"synonyms\""
	IsAdult         *bool                                                                             "json:\"isAdult,omitempty\" graphql:\"isAdult\""
	CountryOfOrigin *string                                                                           "json:\"countryOfOrigin,omitempty\" graphql:\"countryOfOrigin\""
	MeanScore       *int                                                                              "json:\"meanScore,omitempty\" graphql:\"meanScore\""
	Description     *string                                                                           "json:\"description,omitempty\" graphql:\"description\""
	Title           *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title      "json:\"title,omitempty\" graphql:\"title\""
	CoverImage      *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage "json:\"coverImage,omitempty\" graphql:\"coverImage\""
	StartDate       *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate  "json:\"startDate,omitempty\" graphql:\"startDate\""
	EndDate         *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate    "json:\"endDate,omitempty\" graphql:\"endDate\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetID() int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.ID
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetIDMal() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.IDMal
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetSiteURL() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.SiteURL
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetStatus() *MediaStatus {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Status
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetSeason() *MediaSeason {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Season
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetType() *MediaType {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Type
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetFormat() *MediaFormat {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Format
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetBannerImage() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.BannerImage
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetChapters() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Chapters
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetVolumes() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Volumes
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetSynonyms() []*string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Synonyms
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetIsAdult() *bool {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.IsAdult
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetCountryOfOrigin() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.CountryOfOrigin
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetMeanScore() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.MeanScore
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetDescription() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Description
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetTitle() *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_Title {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.Title
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetCoverImage() *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_CoverImage {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.CoverImage
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetStartDate() *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_StartDate {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.StartDate
}
func (t *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation) GetEndDate() *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation_EndDate {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation{}
	}
	return t.EndDate
}

type MangaDetailsById_Media_Recommendations_Edges_Node struct {
	MediaRecommendation *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation "json:\"mediaRecommendation,omitempty\" graphql:\"mediaRecommendation\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges_Node) GetMediaRecommendation() *MangaDetailsById_Media_Recommendations_Edges_Node_MediaRecommendation {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges_Node{}
	}
	return t.MediaRecommendation
}

type MangaDetailsById_Media_Recommendations_Edges struct {
	Node *MangaDetailsById_Media_Recommendations_Edges_Node "json:\"node,omitempty\" graphql:\"node\""
}

func (t *MangaDetailsById_Media_Recommendations_Edges) GetNode() *MangaDetailsById_Media_Recommendations_Edges_Node {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations_Edges{}
	}
	return t.Node
}

type MangaDetailsById_Media_Recommendations struct {
	Edges []*MangaDetailsById_Media_Recommendations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *MangaDetailsById_Media_Recommendations) GetEdges() []*MangaDetailsById_Media_Recommendations_Edges {
	if t == nil {
		t = &MangaDetailsById_Media_Recommendations{}
	}
	return t.Edges
}

type MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title{}
	}
	return t.Romaji
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title{}
	}
	return t.English
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_Title{}
	}
	return t.Native
}

type MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_CoverImage{}
	}
	return t.Color
}

type MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate{}
	}
	return t.Month
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_StartDate{}
	}
	return t.Day
}

type MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate{}
	}
	return t.Year
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate{}
	}
	return t.Month
}
func (t *MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges_Node_BaseManga_EndDate{}
	}
	return t.Day
}

type MangaDetailsById_Media_Relations_Edges struct {
	RelationType *MediaRelation "json:\"relationType,omitempty\" graphql:\"relationType\""
	Node         *BaseManga     "json:\"node,omitempty\" graphql:\"node\""
}

func (t *MangaDetailsById_Media_Relations_Edges) GetRelationType() *MediaRelation {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges{}
	}
	return t.RelationType
}
func (t *MangaDetailsById_Media_Relations_Edges) GetNode() *BaseManga {
	if t == nil {
		t = &MangaDetailsById_Media_Relations_Edges{}
	}
	return t.Node
}

type MangaDetailsById_Media_Relations struct {
	Edges []*MangaDetailsById_Media_Relations_Edges "json:\"edges,omitempty\" graphql:\"edges\""
}

func (t *MangaDetailsById_Media_Relations) GetEdges() []*MangaDetailsById_Media_Relations_Edges {
	if t == nil {
		t = &MangaDetailsById_Media_Relations{}
	}
	return t.Edges
}

type MangaDetailsById_Media struct {
	SiteURL         *string                                 "json:\"siteUrl,omitempty\" graphql:\"siteUrl\""
	ID              int                                     "json:\"id\" graphql:\"id\""
	Duration        *int                                    "json:\"duration,omitempty\" graphql:\"duration\""
	Genres          []*string                               "json:\"genres,omitempty\" graphql:\"genres\""
	Rankings        []*MangaDetailsById_Media_Rankings      "json:\"rankings,omitempty\" graphql:\"rankings\""
	Characters      *MangaDetailsById_Media_Characters      "json:\"characters,omitempty\" graphql:\"characters\""
	Recommendations *MangaDetailsById_Media_Recommendations "json:\"recommendations,omitempty\" graphql:\"recommendations\""
	Relations       *MangaDetailsById_Media_Relations       "json:\"relations,omitempty\" graphql:\"relations\""
}

func (t *MangaDetailsById_Media) GetSiteURL() *string {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.SiteURL
}
func (t *MangaDetailsById_Media) GetID() int {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.ID
}
func (t *MangaDetailsById_Media) GetDuration() *int {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Duration
}
func (t *MangaDetailsById_Media) GetGenres() []*string {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Genres
}
func (t *MangaDetailsById_Media) GetRankings() []*MangaDetailsById_Media_Rankings {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Rankings
}
func (t *MangaDetailsById_Media) GetCharacters() *MangaDetailsById_Media_Characters {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Characters
}
func (t *MangaDetailsById_Media) GetRecommendations() *MangaDetailsById_Media_Recommendations {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Recommendations
}
func (t *MangaDetailsById_Media) GetRelations() *MangaDetailsById_Media_Relations {
	if t == nil {
		t = &MangaDetailsById_Media{}
	}
	return t.Relations
}

type ListManga_Page_PageInfo struct {
	HasNextPage *bool "json:\"hasNextPage,omitempty\" graphql:\"hasNextPage\""
	Total       *int  "json:\"total,omitempty\" graphql:\"total\""
	PerPage     *int  "json:\"perPage,omitempty\" graphql:\"perPage\""
	CurrentPage *int  "json:\"currentPage,omitempty\" graphql:\"currentPage\""
	LastPage    *int  "json:\"lastPage,omitempty\" graphql:\"lastPage\""
}

func (t *ListManga_Page_PageInfo) GetHasNextPage() *bool {
	if t == nil {
		t = &ListManga_Page_PageInfo{}
	}
	return t.HasNextPage
}
func (t *ListManga_Page_PageInfo) GetTotal() *int {
	if t == nil {
		t = &ListManga_Page_PageInfo{}
	}
	return t.Total
}
func (t *ListManga_Page_PageInfo) GetPerPage() *int {
	if t == nil {
		t = &ListManga_Page_PageInfo{}
	}
	return t.PerPage
}
func (t *ListManga_Page_PageInfo) GetCurrentPage() *int {
	if t == nil {
		t = &ListManga_Page_PageInfo{}
	}
	return t.CurrentPage
}
func (t *ListManga_Page_PageInfo) GetLastPage() *int {
	if t == nil {
		t = &ListManga_Page_PageInfo{}
	}
	return t.LastPage
}

type ListManga_Page_Media_BaseManga_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *ListManga_Page_Media_BaseManga_Title) GetUserPreferred() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_Title{}
	}
	return t.UserPreferred
}
func (t *ListManga_Page_Media_BaseManga_Title) GetRomaji() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_Title{}
	}
	return t.Romaji
}
func (t *ListManga_Page_Media_BaseManga_Title) GetEnglish() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_Title{}
	}
	return t.English
}
func (t *ListManga_Page_Media_BaseManga_Title) GetNative() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_Title{}
	}
	return t.Native
}

type ListManga_Page_Media_BaseManga_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *ListManga_Page_Media_BaseManga_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *ListManga_Page_Media_BaseManga_CoverImage) GetLarge() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Large
}
func (t *ListManga_Page_Media_BaseManga_CoverImage) GetMedium() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Medium
}
func (t *ListManga_Page_Media_BaseManga_CoverImage) GetColor() *string {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_CoverImage{}
	}
	return t.Color
}

type ListManga_Page_Media_BaseManga_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListManga_Page_Media_BaseManga_StartDate) GetYear() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Year
}
func (t *ListManga_Page_Media_BaseManga_StartDate) GetMonth() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Month
}
func (t *ListManga_Page_Media_BaseManga_StartDate) GetDay() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_StartDate{}
	}
	return t.Day
}

type ListManga_Page_Media_BaseManga_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *ListManga_Page_Media_BaseManga_EndDate) GetYear() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Year
}
func (t *ListManga_Page_Media_BaseManga_EndDate) GetMonth() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Month
}
func (t *ListManga_Page_Media_BaseManga_EndDate) GetDay() *int {
	if t == nil {
		t = &ListManga_Page_Media_BaseManga_EndDate{}
	}
	return t.Day
}

type ListManga_Page struct {
	PageInfo *ListManga_Page_PageInfo "json:\"pageInfo,omitempty\" graphql:\"pageInfo\""
	Media    []*BaseManga             "json:\"media,omitempty\" graphql:\"media\""
}

func (t *ListManga_Page) GetPageInfo() *ListManga_Page_PageInfo {
	if t == nil {
		t = &ListManga_Page{}
	}
	return t.PageInfo
}
func (t *ListManga_Page) GetMedia() []*BaseManga {
	if t == nil {
		t = &ListManga_Page{}
	}
	return t.Media
}

type ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio struct {
	ID                int    "json:\"id\" graphql:\"id\""
	Name              string "json:\"name\" graphql:\"name\""
	IsAnimationStudio bool   "json:\"isAnimationStudio\" graphql:\"isAnimationStudio\""
}

func (t *ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio) GetID() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio{}
	}
	return t.ID
}
func (t *ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio) GetName() string {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio{}
	}
	return t.Name
}
func (t *ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio) GetIsAnimationStudio() bool {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime_Studios_UserStudioStats_Studio{}
	}
	return t.IsAnimationStudio
}

type ViewerStats_Viewer_Statistics_Anime struct {
	Count           int                     "json:\"count\" graphql:\"count\""
	MinutesWatched  int                     "json:\"minutesWatched\" graphql:\"minutesWatched\""
	EpisodesWatched int                     "json:\"episodesWatched\" graphql:\"episodesWatched\""
	MeanScore       float64                 "json:\"meanScore\" graphql:\"meanScore\""
	Formats         []*UserFormatStats      "json:\"formats,omitempty\" graphql:\"formats\""
	Genres          []*UserGenreStats       "json:\"genres,omitempty\" graphql:\"genres\""
	Statuses        []*UserStatusStats      "json:\"statuses,omitempty\" graphql:\"statuses\""
	Studios         []*UserStudioStats      "json:\"studios,omitempty\" graphql:\"studios\""
	Scores          []*UserScoreStats       "json:\"scores,omitempty\" graphql:\"scores\""
	StartYears      []*UserStartYearStats   "json:\"startYears,omitempty\" graphql:\"startYears\""
	ReleaseYears    []*UserReleaseYearStats "json:\"releaseYears,omitempty\" graphql:\"releaseYears\""
}

func (t *ViewerStats_Viewer_Statistics_Anime) GetCount() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Count
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetMinutesWatched() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.MinutesWatched
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetEpisodesWatched() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.EpisodesWatched
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetMeanScore() float64 {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.MeanScore
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetFormats() []*UserFormatStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Formats
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetGenres() []*UserGenreStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Genres
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetStatuses() []*UserStatusStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Statuses
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetStudios() []*UserStudioStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Studios
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetScores() []*UserScoreStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.Scores
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetStartYears() []*UserStartYearStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.StartYears
}
func (t *ViewerStats_Viewer_Statistics_Anime) GetReleaseYears() []*UserReleaseYearStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Anime{}
	}
	return t.ReleaseYears
}

type ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio struct {
	ID                int    "json:\"id\" graphql:\"id\""
	Name              string "json:\"name\" graphql:\"name\""
	IsAnimationStudio bool   "json:\"isAnimationStudio\" graphql:\"isAnimationStudio\""
}

func (t *ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio) GetID() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio{}
	}
	return t.ID
}
func (t *ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio) GetName() string {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio{}
	}
	return t.Name
}
func (t *ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio) GetIsAnimationStudio() bool {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga_Studios_UserStudioStats_Studio{}
	}
	return t.IsAnimationStudio
}

type ViewerStats_Viewer_Statistics_Manga struct {
	Count        int                     "json:\"count\" graphql:\"count\""
	ChaptersRead int                     "json:\"chaptersRead\" graphql:\"chaptersRead\""
	MeanScore    float64                 "json:\"meanScore\" graphql:\"meanScore\""
	Formats      []*UserFormatStats      "json:\"formats,omitempty\" graphql:\"formats\""
	Genres       []*UserGenreStats       "json:\"genres,omitempty\" graphql:\"genres\""
	Statuses     []*UserStatusStats      "json:\"statuses,omitempty\" graphql:\"statuses\""
	Studios      []*UserStudioStats      "json:\"studios,omitempty\" graphql:\"studios\""
	Scores       []*UserScoreStats       "json:\"scores,omitempty\" graphql:\"scores\""
	StartYears   []*UserStartYearStats   "json:\"startYears,omitempty\" graphql:\"startYears\""
	ReleaseYears []*UserReleaseYearStats "json:\"releaseYears,omitempty\" graphql:\"releaseYears\""
}

func (t *ViewerStats_Viewer_Statistics_Manga) GetCount() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Count
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetChaptersRead() int {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.ChaptersRead
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetMeanScore() float64 {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.MeanScore
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetFormats() []*UserFormatStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Formats
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetGenres() []*UserGenreStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Genres
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetStatuses() []*UserStatusStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Statuses
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetStudios() []*UserStudioStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Studios
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetScores() []*UserScoreStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.Scores
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetStartYears() []*UserStartYearStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.StartYears
}
func (t *ViewerStats_Viewer_Statistics_Manga) GetReleaseYears() []*UserReleaseYearStats {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics_Manga{}
	}
	return t.ReleaseYears
}

type ViewerStats_Viewer_Statistics struct {
	Anime *ViewerStats_Viewer_Statistics_Anime "json:\"anime,omitempty\" graphql:\"anime\""
	Manga *ViewerStats_Viewer_Statistics_Manga "json:\"manga,omitempty\" graphql:\"manga\""
}

func (t *ViewerStats_Viewer_Statistics) GetAnime() *ViewerStats_Viewer_Statistics_Anime {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics{}
	}
	return t.Anime
}
func (t *ViewerStats_Viewer_Statistics) GetManga() *ViewerStats_Viewer_Statistics_Manga {
	if t == nil {
		t = &ViewerStats_Viewer_Statistics{}
	}
	return t.Manga
}

type ViewerStats_Viewer struct {
	Statistics *ViewerStats_Viewer_Statistics "json:\"statistics,omitempty\" graphql:\"statistics\""
}

func (t *ViewerStats_Viewer) GetStatistics() *ViewerStats_Viewer_Statistics {
	if t == nil {
		t = &ViewerStats_Viewer{}
	}
	return t.Statistics
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer struct {
	ID        *string "json:\"id,omitempty\" graphql:\"id\""
	Site      *string "json:\"site,omitempty\" graphql:\"site\""
	Thumbnail *string "json:\"thumbnail,omitempty\" graphql:\"thumbnail\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer) GetID() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer{}
	}
	return t.ID
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer) GetSite() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer{}
	}
	return t.Site
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer) GetThumbnail() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Trailer{}
	}
	return t.Thumbnail
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_Title struct {
	UserPreferred *string "json:\"userPreferred,omitempty\" graphql:\"userPreferred\""
	Romaji        *string "json:\"romaji,omitempty\" graphql:\"romaji\""
	English       *string "json:\"english,omitempty\" graphql:\"english\""
	Native        *string "json:\"native,omitempty\" graphql:\"native\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Title) GetUserPreferred() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Title{}
	}
	return t.UserPreferred
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Title) GetRomaji() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Title{}
	}
	return t.Romaji
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Title) GetEnglish() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Title{}
	}
	return t.English
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_Title) GetNative() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_Title{}
	}
	return t.Native
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage struct {
	ExtraLarge *string "json:\"extraLarge,omitempty\" graphql:\"extraLarge\""
	Large      *string "json:\"large,omitempty\" graphql:\"large\""
	Medium     *string "json:\"medium,omitempty\" graphql:\"medium\""
	Color      *string "json:\"color,omitempty\" graphql:\"color\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage) GetExtraLarge() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage{}
	}
	return t.ExtraLarge
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage) GetLarge() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage{}
	}
	return t.Large
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage) GetMedium() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage{}
	}
	return t.Medium
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage) GetColor() *string {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_CoverImage{}
	}
	return t.Color
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate) GetYear() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate{}
	}
	return t.Year
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate) GetMonth() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate{}
	}
	return t.Month
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate) GetDay() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_StartDate{}
	}
	return t.Day
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate struct {
	Year  *int "json:\"year,omitempty\" graphql:\"year\""
	Month *int "json:\"month,omitempty\" graphql:\"month\""
	Day   *int "json:\"day,omitempty\" graphql:\"day\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate) GetYear() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate{}
	}
	return t.Year
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate) GetMonth() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate{}
	}
	return t.Month
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate) GetDay() *int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_EndDate{}
	}
	return t.Day
}

type StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode struct {
	AiringAt        int "json:\"airingAt\" graphql:\"airingAt\""
	TimeUntilAiring int "json:\"timeUntilAiring\" graphql:\"timeUntilAiring\""
	Episode         int "json:\"episode\" graphql:\"episode\""
}

func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode) GetAiringAt() int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode{}
	}
	return t.AiringAt
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode) GetTimeUntilAiring() int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode{}
	}
	return t.TimeUntilAiring
}
func (t *StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode) GetEpisode() int {
	if t == nil {
		t = &StudioDetails_Studio_Media_Nodes_BaseAnime_NextAiringEpisode{}
	}
	return t.Episode
}

type StudioDetails_Studio_Media struct {
	Nodes []*BaseAnime "json:\"nodes,omitempty\" graphql:\"nodes\""
}

func (t *StudioDetails_Studio_Media) GetNodes() []*BaseAnime {
	if t == nil {
		t = &StudioDetails_Studio_Media{}
	}
	return t.Nodes
}

type StudioDetails_Studio struct {
	ID                int                         "json:\"id\" graphql:\"id\""
	IsAnimationStudio bool                        "json:\"isAnimationStudio\" graphql:\"isAnimationStudio\""
	Name              string                      "json:\"name\" graphql:\"name\""
	Media             *StudioDetails_Studio_Media "json:\"media,omitempty\" graphql:\"media\""
}

func (t *StudioDetails_Studio) GetID() int {
	if t == nil {
		t = &StudioDetails_Studio{}
	}
	return t.ID
}
func (t *StudioDetails_Studio) GetIsAnimationStudio() bool {
	if t == nil {
		t = &StudioDetails_Studio{}
	}
	return t.IsAnimationStudio
}
func (t *StudioDetails_Studio) GetName() string {
	if t == nil {
		t = &StudioDetails_Studio{}
	}
	return t.Name
}
func (t *StudioDetails_Studio) GetMedia() *StudioDetails_Studio_Media {
	if t == nil {
		t = &StudioDetails_Studio{}
	}
	return t.Media
}

type GetViewer_Viewer_Avatar struct {
	Large  *string "json:\"large,omitempty\" graphql:\"large\""
	Medium *string "json:\"medium,omitempty\" graphql:\"medium\""
}

func (t *GetViewer_Viewer_Avatar) GetLarge() *string {
	if t == nil {
		t = &GetViewer_Viewer_Avatar{}
	}
	return t.Large
}
func (t *GetViewer_Viewer_Avatar) GetMedium() *string {
	if t == nil {
		t = &GetViewer_Viewer_Avatar{}
	}
	return t.Medium
}

type GetViewer_Viewer_Options struct {
	DisplayAdultContent *bool   "json:\"displayAdultContent,omitempty\" graphql:\"displayAdultContent\""
	AiringNotifications *bool   "json:\"airingNotifications,omitempty\" graphql:\"airingNotifications\""
	ProfileColor        *string "json:\"profileColor,omitempty\" graphql:\"profileColor\""
}

func (t *GetViewer_Viewer_Options) GetDisplayAdultContent() *bool {
	if t == nil {
		t = &GetViewer_Viewer_Options{}
	}
	return t.DisplayAdultContent
}
func (t *GetViewer_Viewer_Options) GetAiringNotifications() *bool {
	if t == nil {
		t = &GetViewer_Viewer_Options{}
	}
	return t.AiringNotifications
}
func (t *GetViewer_Viewer_Options) GetProfileColor() *string {
	if t == nil {
		t = &GetViewer_Viewer_Options{}
	}
	return t.ProfileColor
}

type GetViewer_Viewer struct {
	Name        string                    "json:\"name\" graphql:\"name\""
	Avatar      *GetViewer_Viewer_Avatar  "json:\"avatar,omitempty\" graphql:\"avatar\""
	BannerImage *string                   "json:\"bannerImage,omitempty\" graphql:\"bannerImage\""
	IsBlocked   *bool                     "json:\"isBlocked,omitempty\" graphql:\"isBlocked\""
	Options     *GetViewer_Viewer_Options "json:\"options,omitempty\" graphql:\"options\""
}

func (t *GetViewer_Viewer) GetName() string {
	if t == nil {
		t = &GetViewer_Viewer{}
	}
	return t.Name
}
func (t *GetViewer_Viewer) GetAvatar() *GetViewer_Viewer_Avatar {
	if t == nil {
		t = &GetViewer_Viewer{}
	}
	return t.Avatar
}
func (t *GetViewer_Viewer) GetBannerImage() *string {
	if t == nil {
		t = &GetViewer_Viewer{}
	}
	return t.BannerImage
}
func (t *GetViewer_Viewer) GetIsBlocked() *bool {
	if t == nil {
		t = &GetViewer_Viewer{}
	}
	return t.IsBlocked
}
func (t *GetViewer_Viewer) GetOptions() *GetViewer_Viewer_Options {
	if t == nil {
		t = &GetViewer_Viewer{}
	}
	return t.Options
}

type AnimeCollection struct {
	MediaListCollection *AnimeCollection_MediaListCollection "json:\"MediaListCollection,omitempty\" graphql:\"MediaListCollection\""
}

func (t *AnimeCollection) GetMediaListCollection() *AnimeCollection_MediaListCollection {
	if t == nil {
		t = &AnimeCollection{}
	}
	return t.MediaListCollection
}

type AnimeCollectionWithRelations struct {
	MediaListCollection *AnimeCollectionWithRelations_MediaListCollection "json:\"MediaListCollection,omitempty\" graphql:\"MediaListCollection\""
}

func (t *AnimeCollectionWithRelations) GetMediaListCollection() *AnimeCollectionWithRelations_MediaListCollection {
	if t == nil {
		t = &AnimeCollectionWithRelations{}
	}
	return t.MediaListCollection
}

type BaseAnimeByMalID struct {
	Media *BaseAnime "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *BaseAnimeByMalID) GetMedia() *BaseAnime {
	if t == nil {
		t = &BaseAnimeByMalID{}
	}
	return t.Media
}

type BaseAnimeByID struct {
	Media *BaseAnime "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *BaseAnimeByID) GetMedia() *BaseAnime {
	if t == nil {
		t = &BaseAnimeByID{}
	}
	return t.Media
}

type SearchBaseAnimeByIds struct {
	Page *SearchBaseAnimeByIds_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *SearchBaseAnimeByIds) GetPage() *SearchBaseAnimeByIds_Page {
	if t == nil {
		t = &SearchBaseAnimeByIds{}
	}
	return t.Page
}

type CompleteAnimeByID struct {
	Media *CompleteAnime "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *CompleteAnimeByID) GetMedia() *CompleteAnime {
	if t == nil {
		t = &CompleteAnimeByID{}
	}
	return t.Media
}

type AnimeDetailsByID struct {
	Media *AnimeDetailsById_Media "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *AnimeDetailsByID) GetMedia() *AnimeDetailsById_Media {
	if t == nil {
		t = &AnimeDetailsByID{}
	}
	return t.Media
}

type ListAnime struct {
	Page *ListAnime_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *ListAnime) GetPage() *ListAnime_Page {
	if t == nil {
		t = &ListAnime{}
	}
	return t.Page
}

type ListRecentAnime struct {
	Page *ListRecentAnime_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *ListRecentAnime) GetPage() *ListRecentAnime_Page {
	if t == nil {
		t = &ListRecentAnime{}
	}
	return t.Page
}

type AnimeAiringSchedule struct {
	Ongoing      *AnimeAiringSchedule_Ongoing      "json:\"ongoing,omitempty\" graphql:\"ongoing\""
	OngoingNext  *AnimeAiringSchedule_OngoingNext  "json:\"ongoingNext,omitempty\" graphql:\"ongoingNext\""
	Upcoming     *AnimeAiringSchedule_Upcoming     "json:\"upcoming,omitempty\" graphql:\"upcoming\""
	UpcomingNext *AnimeAiringSchedule_UpcomingNext "json:\"upcomingNext,omitempty\" graphql:\"upcomingNext\""
	Preceding    *AnimeAiringSchedule_Preceding    "json:\"preceding,omitempty\" graphql:\"preceding\""
}

func (t *AnimeAiringSchedule) GetOngoing() *AnimeAiringSchedule_Ongoing {
	if t == nil {
		t = &AnimeAiringSchedule{}
	}
	return t.Ongoing
}
func (t *AnimeAiringSchedule) GetOngoingNext() *AnimeAiringSchedule_OngoingNext {
	if t == nil {
		t = &AnimeAiringSchedule{}
	}
	return t.OngoingNext
}
func (t *AnimeAiringSchedule) GetUpcoming() *AnimeAiringSchedule_Upcoming {
	if t == nil {
		t = &AnimeAiringSchedule{}
	}
	return t.Upcoming
}
func (t *AnimeAiringSchedule) GetUpcomingNext() *AnimeAiringSchedule_UpcomingNext {
	if t == nil {
		t = &AnimeAiringSchedule{}
	}
	return t.UpcomingNext
}
func (t *AnimeAiringSchedule) GetPreceding() *AnimeAiringSchedule_Preceding {
	if t == nil {
		t = &AnimeAiringSchedule{}
	}
	return t.Preceding
}

type AnimeAiringScheduleRaw struct {
	Page *AnimeAiringScheduleRaw_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *AnimeAiringScheduleRaw) GetPage() *AnimeAiringScheduleRaw_Page {
	if t == nil {
		t = &AnimeAiringScheduleRaw{}
	}
	return t.Page
}

type UpdateMediaListEntry struct {
	SaveMediaListEntry *UpdateMediaListEntry_SaveMediaListEntry "json:\"SaveMediaListEntry,omitempty\" graphql:\"SaveMediaListEntry\""
}

func (t *UpdateMediaListEntry) GetSaveMediaListEntry() *UpdateMediaListEntry_SaveMediaListEntry {
	if t == nil {
		t = &UpdateMediaListEntry{}
	}
	return t.SaveMediaListEntry
}

type UpdateMediaListEntryProgress struct {
	SaveMediaListEntry *UpdateMediaListEntryProgress_SaveMediaListEntry "json:\"SaveMediaListEntry,omitempty\" graphql:\"SaveMediaListEntry\""
}

func (t *UpdateMediaListEntryProgress) GetSaveMediaListEntry() *UpdateMediaListEntryProgress_SaveMediaListEntry {
	if t == nil {
		t = &UpdateMediaListEntryProgress{}
	}
	return t.SaveMediaListEntry
}

type DeleteEntry struct {
	DeleteMediaListEntry *DeleteEntry_DeleteMediaListEntry "json:\"DeleteMediaListEntry,omitempty\" graphql:\"DeleteMediaListEntry\""
}

func (t *DeleteEntry) GetDeleteMediaListEntry() *DeleteEntry_DeleteMediaListEntry {
	if t == nil {
		t = &DeleteEntry{}
	}
	return t.DeleteMediaListEntry
}

type UpdateMediaListEntryRepeat struct {
	SaveMediaListEntry *UpdateMediaListEntryRepeat_SaveMediaListEntry "json:\"SaveMediaListEntry,omitempty\" graphql:\"SaveMediaListEntry\""
}

func (t *UpdateMediaListEntryRepeat) GetSaveMediaListEntry() *UpdateMediaListEntryRepeat_SaveMediaListEntry {
	if t == nil {
		t = &UpdateMediaListEntryRepeat{}
	}
	return t.SaveMediaListEntry
}

type MangaCollection struct {
	MediaListCollection *MangaCollection_MediaListCollection "json:\"MediaListCollection,omitempty\" graphql:\"MediaListCollection\""
}

func (t *MangaCollection) GetMediaListCollection() *MangaCollection_MediaListCollection {
	if t == nil {
		t = &MangaCollection{}
	}
	return t.MediaListCollection
}

type SearchBaseManga struct {
	Page *SearchBaseManga_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *SearchBaseManga) GetPage() *SearchBaseManga_Page {
	if t == nil {
		t = &SearchBaseManga{}
	}
	return t.Page
}

type BaseMangaByID struct {
	Media *BaseManga "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *BaseMangaByID) GetMedia() *BaseManga {
	if t == nil {
		t = &BaseMangaByID{}
	}
	return t.Media
}

type MangaDetailsByID struct {
	Media *MangaDetailsById_Media "json:\"Media,omitempty\" graphql:\"Media\""
}

func (t *MangaDetailsByID) GetMedia() *MangaDetailsById_Media {
	if t == nil {
		t = &MangaDetailsByID{}
	}
	return t.Media
}

type ListManga struct {
	Page *ListManga_Page "json:\"Page,omitempty\" graphql:\"Page\""
}

func (t *ListManga) GetPage() *ListManga_Page {
	if t == nil {
		t = &ListManga{}
	}
	return t.Page
}

type ViewerStats struct {
	Viewer *ViewerStats_Viewer "json:\"Viewer,omitempty\" graphql:\"Viewer\""
}

func (t *ViewerStats) GetViewer() *ViewerStats_Viewer {
	if t == nil {
		t = &ViewerStats{}
	}
	return t.Viewer
}

type StudioDetails struct {
	Studio *StudioDetails_Studio "json:\"Studio,omitempty\" graphql:\"Studio\""
}

func (t *StudioDetails) GetStudio() *StudioDetails_Studio {
	if t == nil {
		t = &StudioDetails{}
	}
	return t.Studio
}

type GetViewer struct {
	Viewer *GetViewer_Viewer "json:\"Viewer,omitempty\" graphql:\"Viewer\""
}

func (t *GetViewer) GetViewer() *GetViewer_Viewer {
	if t == nil {
		t = &GetViewer{}
	}
	return t.Viewer
}

const AnimeCollectionDocument = `query AnimeCollection ($userName: String) {
	MediaListCollection(userName: $userName, forceSingleCompletedList: true, type: ANIME) {
		lists {
			status
			name
			isCustomList
			entries {
				id
				score(format: POINT_100)
				progress
				status
				notes
				repeat
				private
				startedAt {
					year
					month
					day
				}
				completedAt {
					year
					month
					day
				}
				media {
					... baseAnime
				}
			}
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) AnimeCollection(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*AnimeCollection, error) {
	vars := map[string]any{
		"userName": userName,
	}

	var res AnimeCollection
	if err := c.Client.Post(ctx, "AnimeCollection", AnimeCollectionDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const AnimeCollectionWithRelationsDocument = `query AnimeCollectionWithRelations ($userName: String) {
	MediaListCollection(userName: $userName, forceSingleCompletedList: true, type: ANIME) {
		lists {
			status
			name
			isCustomList
			entries {
				id
				score(format: POINT_100)
				progress
				status
				notes
				repeat
				private
				startedAt {
					year
					month
					day
				}
				completedAt {
					year
					month
					day
				}
				media {
					... completeAnime
				}
			}
		}
	}
}
fragment completeAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	seasonYear
	type
	format
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
	relations {
		edges {
			relationType(version: 2)
			node {
				... baseAnime
			}
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) AnimeCollectionWithRelations(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*AnimeCollectionWithRelations, error) {
	vars := map[string]any{
		"userName": userName,
	}

	var res AnimeCollectionWithRelations
	if err := c.Client.Post(ctx, "AnimeCollectionWithRelations", AnimeCollectionWithRelationsDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const BaseAnimeByMalIDDocument = `query BaseAnimeByMalId ($id: Int) {
	Media(idMal: $id, type: ANIME) {
		... baseAnime
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) BaseAnimeByMalID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseAnimeByMalID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res BaseAnimeByMalID
	if err := c.Client.Post(ctx, "BaseAnimeByMalId", BaseAnimeByMalIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const BaseAnimeByIDDocument = `query BaseAnimeById ($id: Int) {
	Media(id: $id, type: ANIME) {
		... baseAnime
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) BaseAnimeByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseAnimeByID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res BaseAnimeByID
	if err := c.Client.Post(ctx, "BaseAnimeById", BaseAnimeByIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const SearchBaseAnimeByIdsDocument = `query SearchBaseAnimeByIds ($ids: [Int], $page: Int, $perPage: Int, $status: [MediaStatus], $inCollection: Boolean, $sort: [MediaSort], $season: MediaSeason, $year: Int, $genre: String, $format: MediaFormat) {
	Page(page: $page, perPage: $perPage) {
		pageInfo {
			hasNextPage
		}
		media(id_in: $ids, type: ANIME, status_in: $status, onList: $inCollection, sort: $sort, season: $season, seasonYear: $year, genre: $genre, format: $format) {
			... baseAnime
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) SearchBaseAnimeByIds(ctx context.Context, ids []*int, page *int, perPage *int, status []*MediaStatus, inCollection *bool, sort []*MediaSort, season *MediaSeason, year *int, genre *string, format *MediaFormat, interceptors ...clientv2.RequestInterceptor) (*SearchBaseAnimeByIds, error) {
	vars := map[string]any{
		"ids":          ids,
		"page":         page,
		"perPage":      perPage,
		"status":       status,
		"inCollection": inCollection,
		"sort":         sort,
		"season":       season,
		"year":         year,
		"genre":        genre,
		"format":       format,
	}

	var res SearchBaseAnimeByIds
	if err := c.Client.Post(ctx, "SearchBaseAnimeByIds", SearchBaseAnimeByIdsDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const CompleteAnimeByIDDocument = `query CompleteAnimeById ($id: Int) {
	Media(id: $id, type: ANIME) {
		... completeAnime
	}
}
fragment completeAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	seasonYear
	type
	format
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
	relations {
		edges {
			relationType(version: 2)
			node {
				... baseAnime
			}
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) CompleteAnimeByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*CompleteAnimeByID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res CompleteAnimeByID
	if err := c.Client.Post(ctx, "CompleteAnimeById", CompleteAnimeByIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const AnimeDetailsByIDDocument = `query AnimeDetailsById ($id: Int) {
	Media(id: $id, type: ANIME) {
		siteUrl
		id
		duration
		genres
		averageScore
		popularity
		meanScore
		description
		trailer {
			id
			site
			thumbnail
		}
		startDate {
			year
			month
			day
		}
		endDate {
			year
			month
			day
		}
		studios(isMain: true) {
			nodes {
				name
				id
			}
		}
		characters(sort: [ROLE]) {
			edges {
				id
				role
				name
				node {
					... baseCharacter
				}
			}
		}
		staff(sort: [RELEVANCE]) {
			edges {
				role
				node {
					name {
						full
					}
					id
				}
			}
		}
		rankings {
			context
			type
			rank
			year
			format
			allTime
			season
		}
		recommendations(page: 1, perPage: 8, sort: RATING_DESC) {
			edges {
				node {
					mediaRecommendation {
						id
						idMal
						siteUrl
						status(version: 2)
						isAdult
						season
						type
						format
						meanScore
						description
						episodes
						trailer {
							id
							site
							thumbnail
						}
						startDate {
							year
							month
							day
						}
						coverImage {
							extraLarge
							large
							medium
							color
						}
						bannerImage
						title {
							romaji
							english
							native
							userPreferred
						}
					}
				}
			}
		}
		relations {
			edges {
				relationType(version: 2)
				node {
					... baseAnime
				}
			}
		}
	}
}
fragment baseCharacter on Character {
	id
	isFavourite
	gender
	age
	dateOfBirth {
		year
		month
		day
	}
	name {
		full
		native
		alternative
	}
	image {
		large
	}
	description
	siteUrl
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) AnimeDetailsByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*AnimeDetailsByID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res AnimeDetailsByID
	if err := c.Client.Post(ctx, "AnimeDetailsById", AnimeDetailsByIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const ListAnimeDocument = `query ListAnime ($page: Int, $search: String, $perPage: Int, $sort: [MediaSort], $status: [MediaStatus], $genres: [String], $averageScore_greater: Int, $season: MediaSeason, $seasonYear: Int, $format: MediaFormat, $isAdult: Boolean) {
	Page(page: $page, perPage: $perPage) {
		pageInfo {
			hasNextPage
			total
			perPage
			currentPage
			lastPage
		}
		media(type: ANIME, search: $search, sort: $sort, status_in: $status, isAdult: $isAdult, format: $format, genre_in: $genres, averageScore_greater: $averageScore_greater, season: $season, seasonYear: $seasonYear, format_not: MUSIC) {
			... baseAnime
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) ListAnime(ctx context.Context, page *int, search *string, perPage *int, sort []*MediaSort, status []*MediaStatus, genres []*string, averageScoreGreater *int, season *MediaSeason, seasonYear *int, format *MediaFormat, isAdult *bool, interceptors ...clientv2.RequestInterceptor) (*ListAnime, error) {
	vars := map[string]any{
		"page":                 page,
		"search":               search,
		"perPage":              perPage,
		"sort":                 sort,
		"status":               status,
		"genres":               genres,
		"averageScore_greater": averageScoreGreater,
		"season":               season,
		"seasonYear":           seasonYear,
		"format":               format,
		"isAdult":              isAdult,
	}

	var res ListAnime
	if err := c.Client.Post(ctx, "ListAnime", ListAnimeDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const ListRecentAnimeDocument = `query ListRecentAnime ($page: Int, $perPage: Int, $airingAt_greater: Int, $airingAt_lesser: Int, $notYetAired: Boolean = false) {
	Page(page: $page, perPage: $perPage) {
		pageInfo {
			hasNextPage
			total
			perPage
			currentPage
			lastPage
		}
		airingSchedules(notYetAired: $notYetAired, sort: TIME_DESC, airingAt_greater: $airingAt_greater, airingAt_lesser: $airingAt_lesser) {
			id
			airingAt
			episode
			timeUntilAiring
			media {
				... baseAnime
			}
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) ListRecentAnime(ctx context.Context, page *int, perPage *int, airingAtGreater *int, airingAtLesser *int, notYetAired *bool, interceptors ...clientv2.RequestInterceptor) (*ListRecentAnime, error) {
	vars := map[string]any{
		"page":             page,
		"perPage":          perPage,
		"airingAt_greater": airingAtGreater,
		"airingAt_lesser":  airingAtLesser,
		"notYetAired":      notYetAired,
	}

	var res ListRecentAnime
	if err := c.Client.Post(ctx, "ListRecentAnime", ListRecentAnimeDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const AnimeAiringScheduleDocument = `query AnimeAiringSchedule ($ids: [Int], $season: MediaSeason, $seasonYear: Int, $previousSeason: MediaSeason, $previousSeasonYear: Int, $nextSeason: MediaSeason, $nextSeasonYear: Int) {
	ongoing: Page {
		media(id_in: $ids, type: ANIME, season: $season, seasonYear: $seasonYear, onList: true) {
			... animeSchedule
		}
	}
	ongoingNext: Page(page: 2) {
		media(id_in: $ids, type: ANIME, season: $season, seasonYear: $seasonYear, onList: true) {
			... animeSchedule
		}
	}
	upcoming: Page {
		media(id_in: $ids, type: ANIME, season: $nextSeason, seasonYear: $nextSeasonYear, sort: [START_DATE], onList: true) {
			... animeSchedule
		}
	}
	upcomingNext: Page(page: 2) {
		media(id_in: $ids, type: ANIME, season: $nextSeason, seasonYear: $nextSeasonYear, sort: [START_DATE], onList: true) {
			... animeSchedule
		}
	}
	preceding: Page {
		media(id_in: $ids, type: ANIME, season: $previousSeason, seasonYear: $previousSeasonYear, onList: true) {
			... animeSchedule
		}
	}
}
fragment animeSchedule on Media {
	id
	idMal
	previous: airingSchedule(notYetAired: false, perPage: 30) {
		nodes {
			airingAt
			timeUntilAiring
			episode
		}
	}
	upcoming: airingSchedule(notYetAired: true, perPage: 30) {
		nodes {
			airingAt
			timeUntilAiring
			episode
		}
	}
}
`

func (c *Client) AnimeAiringSchedule(ctx context.Context, ids []*int, season *MediaSeason, seasonYear *int, previousSeason *MediaSeason, previousSeasonYear *int, nextSeason *MediaSeason, nextSeasonYear *int, interceptors ...clientv2.RequestInterceptor) (*AnimeAiringSchedule, error) {
	vars := map[string]any{
		"ids":                ids,
		"season":             season,
		"seasonYear":         seasonYear,
		"previousSeason":     previousSeason,
		"previousSeasonYear": previousSeasonYear,
		"nextSeason":         nextSeason,
		"nextSeasonYear":     nextSeasonYear,
	}

	var res AnimeAiringSchedule
	if err := c.Client.Post(ctx, "AnimeAiringSchedule", AnimeAiringScheduleDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const AnimeAiringScheduleRawDocument = `query AnimeAiringScheduleRaw ($ids: [Int]) {
	Page {
		media(id_in: $ids, type: ANIME, onList: true) {
			... animeSchedule
		}
	}
}
fragment animeSchedule on Media {
	id
	idMal
	previous: airingSchedule(notYetAired: false, perPage: 30) {
		nodes {
			airingAt
			timeUntilAiring
			episode
		}
	}
	upcoming: airingSchedule(notYetAired: true, perPage: 30) {
		nodes {
			airingAt
			timeUntilAiring
			episode
		}
	}
}
`

func (c *Client) AnimeAiringScheduleRaw(ctx context.Context, ids []*int, interceptors ...clientv2.RequestInterceptor) (*AnimeAiringScheduleRaw, error) {
	vars := map[string]any{
		"ids": ids,
	}

	var res AnimeAiringScheduleRaw
	if err := c.Client.Post(ctx, "AnimeAiringScheduleRaw", AnimeAiringScheduleRawDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const UpdateMediaListEntryDocument = `mutation UpdateMediaListEntry ($mediaId: Int, $status: MediaListStatus, $scoreRaw: Int, $progress: Int, $startedAt: FuzzyDateInput, $completedAt: FuzzyDateInput) {
	SaveMediaListEntry(mediaId: $mediaId, status: $status, scoreRaw: $scoreRaw, progress: $progress, startedAt: $startedAt, completedAt: $completedAt) {
		id
	}
}
`

func (c *Client) UpdateMediaListEntry(ctx context.Context, mediaID *int, status *MediaListStatus, scoreRaw *int, progress *int, startedAt *FuzzyDateInput, completedAt *FuzzyDateInput, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntry, error) {
	vars := map[string]any{
		"mediaId":     mediaID,
		"status":      status,
		"scoreRaw":    scoreRaw,
		"progress":    progress,
		"startedAt":   startedAt,
		"completedAt": completedAt,
	}

	var res UpdateMediaListEntry
	if err := c.Client.Post(ctx, "UpdateMediaListEntry", UpdateMediaListEntryDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const UpdateMediaListEntryProgressDocument = `mutation UpdateMediaListEntryProgress ($mediaId: Int, $progress: Int, $status: MediaListStatus) {
	SaveMediaListEntry(mediaId: $mediaId, progress: $progress, status: $status) {
		id
	}
}
`

func (c *Client) UpdateMediaListEntryProgress(ctx context.Context, mediaID *int, progress *int, status *MediaListStatus, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntryProgress, error) {
	vars := map[string]any{
		"mediaId":  mediaID,
		"progress": progress,
		"status":   status,
	}

	var res UpdateMediaListEntryProgress
	if err := c.Client.Post(ctx, "UpdateMediaListEntryProgress", UpdateMediaListEntryProgressDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const DeleteEntryDocument = `mutation DeleteEntry ($mediaListEntryId: Int) {
	DeleteMediaListEntry(id: $mediaListEntryId) {
		deleted
	}
}
`

func (c *Client) DeleteEntry(ctx context.Context, mediaListEntryID *int, interceptors ...clientv2.RequestInterceptor) (*DeleteEntry, error) {
	vars := map[string]any{
		"mediaListEntryId": mediaListEntryID,
	}

	var res DeleteEntry
	if err := c.Client.Post(ctx, "DeleteEntry", DeleteEntryDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const UpdateMediaListEntryRepeatDocument = `mutation UpdateMediaListEntryRepeat ($mediaId: Int, $repeat: Int) {
	SaveMediaListEntry(mediaId: $mediaId, repeat: $repeat) {
		id
	}
}
`

func (c *Client) UpdateMediaListEntryRepeat(ctx context.Context, mediaID *int, repeat *int, interceptors ...clientv2.RequestInterceptor) (*UpdateMediaListEntryRepeat, error) {
	vars := map[string]any{
		"mediaId": mediaID,
		"repeat":  repeat,
	}

	var res UpdateMediaListEntryRepeat
	if err := c.Client.Post(ctx, "UpdateMediaListEntryRepeat", UpdateMediaListEntryRepeatDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const MangaCollectionDocument = `query MangaCollection ($userName: String) {
	MediaListCollection(userName: $userName, forceSingleCompletedList: true, type: MANGA) {
		lists {
			status
			name
			isCustomList
			entries {
				id
				score(format: POINT_100)
				progress
				status
				notes
				repeat
				private
				startedAt {
					year
					month
					day
				}
				completedAt {
					year
					month
					day
				}
				media {
					... baseManga
				}
			}
		}
	}
}
fragment baseManga on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	bannerImage
	chapters
	volumes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
}
`

func (c *Client) MangaCollection(ctx context.Context, userName *string, interceptors ...clientv2.RequestInterceptor) (*MangaCollection, error) {
	vars := map[string]any{
		"userName": userName,
	}

	var res MangaCollection
	if err := c.Client.Post(ctx, "MangaCollection", MangaCollectionDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const SearchBaseMangaDocument = `query SearchBaseManga ($page: Int, $perPage: Int, $sort: [MediaSort], $search: String, $status: [MediaStatus]) {
	Page(page: $page, perPage: $perPage) {
		pageInfo {
			hasNextPage
		}
		media(type: MANGA, search: $search, sort: $sort, status_in: $status, format_not: NOVEL) {
			... baseManga
		}
	}
}
fragment baseManga on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	bannerImage
	chapters
	volumes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
}
`

func (c *Client) SearchBaseManga(ctx context.Context, page *int, perPage *int, sort []*MediaSort, search *string, status []*MediaStatus, interceptors ...clientv2.RequestInterceptor) (*SearchBaseManga, error) {
	vars := map[string]any{
		"page":    page,
		"perPage": perPage,
		"sort":    sort,
		"search":  search,
		"status":  status,
	}

	var res SearchBaseManga
	if err := c.Client.Post(ctx, "SearchBaseManga", SearchBaseMangaDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const BaseMangaByIDDocument = `query BaseMangaById ($id: Int) {
	Media(id: $id, type: MANGA) {
		... baseManga
	}
}
fragment baseManga on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	bannerImage
	chapters
	volumes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
}
`

func (c *Client) BaseMangaByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*BaseMangaByID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res BaseMangaByID
	if err := c.Client.Post(ctx, "BaseMangaById", BaseMangaByIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const MangaDetailsByIDDocument = `query MangaDetailsById ($id: Int) {
	Media(id: $id, type: MANGA) {
		siteUrl
		id
		duration
		genres
		rankings {
			context
			type
			rank
			year
			format
			allTime
			season
		}
		characters(sort: [ROLE]) {
			edges {
				id
				role
				name
				node {
					... baseCharacter
				}
			}
		}
		recommendations(page: 1, perPage: 8, sort: RATING_DESC) {
			edges {
				node {
					mediaRecommendation {
						id
						idMal
						siteUrl
						status(version: 2)
						season
						type
						format
						bannerImage
						chapters
						volumes
						synonyms
						isAdult
						countryOfOrigin
						meanScore
						description
						title {
							userPreferred
							romaji
							english
							native
						}
						coverImage {
							extraLarge
							large
							medium
							color
						}
						startDate {
							year
							month
							day
						}
						endDate {
							year
							month
							day
						}
					}
				}
			}
		}
		relations {
			edges {
				relationType(version: 2)
				node {
					... baseManga
				}
			}
		}
	}
}
fragment baseCharacter on Character {
	id
	isFavourite
	gender
	age
	dateOfBirth {
		year
		month
		day
	}
	name {
		full
		native
		alternative
	}
	image {
		large
	}
	description
	siteUrl
}
fragment baseManga on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	bannerImage
	chapters
	volumes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
}
`

func (c *Client) MangaDetailsByID(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*MangaDetailsByID, error) {
	vars := map[string]any{
		"id": id,
	}

	var res MangaDetailsByID
	if err := c.Client.Post(ctx, "MangaDetailsById", MangaDetailsByIDDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const ListMangaDocument = `query ListManga ($page: Int, $search: String, $perPage: Int, $sort: [MediaSort], $status: [MediaStatus], $genres: [String], $averageScore_greater: Int, $startDate_greater: FuzzyDateInt, $startDate_lesser: FuzzyDateInt, $format: MediaFormat, $countryOfOrigin: CountryCode, $isAdult: Boolean) {
	Page(page: $page, perPage: $perPage) {
		pageInfo {
			hasNextPage
			total
			perPage
			currentPage
			lastPage
		}
		media(type: MANGA, isAdult: $isAdult, countryOfOrigin: $countryOfOrigin, search: $search, sort: $sort, status_in: $status, format: $format, genre_in: $genres, averageScore_greater: $averageScore_greater, startDate_greater: $startDate_greater, startDate_lesser: $startDate_lesser, format_not: NOVEL) {
			... baseManga
		}
	}
}
fragment baseManga on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	bannerImage
	chapters
	volumes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
}
`

func (c *Client) ListManga(ctx context.Context, page *int, search *string, perPage *int, sort []*MediaSort, status []*MediaStatus, genres []*string, averageScoreGreater *int, startDateGreater *string, startDateLesser *string, format *MediaFormat, countryOfOrigin *string, isAdult *bool, interceptors ...clientv2.RequestInterceptor) (*ListManga, error) {
	vars := map[string]any{
		"page":                 page,
		"search":               search,
		"perPage":              perPage,
		"sort":                 sort,
		"status":               status,
		"genres":               genres,
		"averageScore_greater": averageScoreGreater,
		"startDate_greater":    startDateGreater,
		"startDate_lesser":     startDateLesser,
		"format":               format,
		"countryOfOrigin":      countryOfOrigin,
		"isAdult":              isAdult,
	}

	var res ListManga
	if err := c.Client.Post(ctx, "ListManga", ListMangaDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const ViewerStatsDocument = `query ViewerStats {
	Viewer {
		statistics {
			anime {
				count
				minutesWatched
				episodesWatched
				meanScore
				formats {
					... UserFormatStats
				}
				genres {
					... UserGenreStats
				}
				statuses {
					... UserStatusStats
				}
				studios {
					... UserStudioStats
				}
				scores {
					... UserScoreStats
				}
				startYears {
					... UserStartYearStats
				}
				releaseYears {
					... UserReleaseYearStats
				}
			}
			manga {
				count
				chaptersRead
				meanScore
				formats {
					... UserFormatStats
				}
				genres {
					... UserGenreStats
				}
				statuses {
					... UserStatusStats
				}
				studios {
					... UserStudioStats
				}
				scores {
					... UserScoreStats
				}
				startYears {
					... UserStartYearStats
				}
				releaseYears {
					... UserReleaseYearStats
				}
			}
		}
	}
}
fragment UserFormatStats on UserFormatStatistic {
	format
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserGenreStats on UserGenreStatistic {
	genre
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserStatusStats on UserStatusStatistic {
	status
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserStudioStats on UserStudioStatistic {
	studio {
		id
		name
		isAnimationStudio
	}
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserScoreStats on UserScoreStatistic {
	score
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserStartYearStats on UserStartYearStatistic {
	startYear
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
fragment UserReleaseYearStats on UserReleaseYearStatistic {
	releaseYear
	meanScore
	count
	minutesWatched
	mediaIds
	chaptersRead
}
`

func (c *Client) ViewerStats(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*ViewerStats, error) {
	vars := map[string]any{}

	var res ViewerStats
	if err := c.Client.Post(ctx, "ViewerStats", ViewerStatsDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const StudioDetailsDocument = `query StudioDetails ($id: Int) {
	Studio(id: $id) {
		id
		isAnimationStudio
		name
		media(perPage: 80, sort: TRENDING_DESC, isMain: true) {
			nodes {
				... baseAnime
			}
		}
	}
}
fragment baseAnime on Media {
	id
	idMal
	siteUrl
	status(version: 2)
	season
	type
	format
	seasonYear
	bannerImage
	episodes
	synonyms
	isAdult
	countryOfOrigin
	meanScore
	description
	genres
	duration
	trailer {
		id
		site
		thumbnail
	}
	title {
		userPreferred
		romaji
		english
		native
	}
	coverImage {
		extraLarge
		large
		medium
		color
	}
	startDate {
		year
		month
		day
	}
	endDate {
		year
		month
		day
	}
	nextAiringEpisode {
		airingAt
		timeUntilAiring
		episode
	}
}
`

func (c *Client) StudioDetails(ctx context.Context, id *int, interceptors ...clientv2.RequestInterceptor) (*StudioDetails, error) {
	vars := map[string]any{
		"id": id,
	}

	var res StudioDetails
	if err := c.Client.Post(ctx, "StudioDetails", StudioDetailsDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

const GetViewerDocument = `query GetViewer {
	Viewer {
		name
		avatar {
			large
			medium
		}
		bannerImage
		isBlocked
		options {
			displayAdultContent
			airingNotifications
			profileColor
		}
	}
}
`

func (c *Client) GetViewer(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetViewer, error) {
	vars := map[string]any{}

	var res GetViewer
	if err := c.Client.Post(ctx, "GetViewer", GetViewerDocument, &res, vars, interceptors...); err != nil {
		if c.Client.ParseDataWhenErrors {
			return &res, err
		}

		return nil, err
	}

	return &res, nil
}

var DocumentOperationNames = map[string]string{
	AnimeCollectionDocument:              "AnimeCollection",
	AnimeCollectionWithRelationsDocument: "AnimeCollectionWithRelations",
	BaseAnimeByMalIDDocument:             "BaseAnimeByMalId",
	BaseAnimeByIDDocument:                "BaseAnimeById",
	SearchBaseAnimeByIdsDocument:         "SearchBaseAnimeByIds",
	CompleteAnimeByIDDocument:            "CompleteAnimeById",
	AnimeDetailsByIDDocument:             "AnimeDetailsById",
	ListAnimeDocument:                    "ListAnime",
	ListRecentAnimeDocument:              "ListRecentAnime",
	AnimeAiringScheduleDocument:          "AnimeAiringSchedule",
	AnimeAiringScheduleRawDocument:       "AnimeAiringScheduleRaw",
	UpdateMediaListEntryDocument:         "UpdateMediaListEntry",
	UpdateMediaListEntryProgressDocument: "UpdateMediaListEntryProgress",
	DeleteEntryDocument:                  "DeleteEntry",
	UpdateMediaListEntryRepeatDocument:   "UpdateMediaListEntryRepeat",
	MangaCollectionDocument:              "MangaCollection",
	SearchBaseMangaDocument:              "SearchBaseManga",
	BaseMangaByIDDocument:                "BaseMangaById",
	MangaDetailsByIDDocument:             "MangaDetailsById",
	ListMangaDocument:                    "ListManga",
	ViewerStatsDocument:                  "ViewerStats",
	StudioDetailsDocument:                "StudioDetails",
	GetViewerDocument:                    "GetViewer",
}