# Generated by ariadne-codegen on 2023-06-06 10:50
# Source: graphql/queries.graphql

from typing import Any, List, Optional, Union

from .air_quality_device_element_reads import AirQualityDeviceElementReads
from .air_quality_devices import AirQualityDevices
from .async_base_client import AsyncBaseClient
from .base_model import UNSET, UnsetType
from .competition_document import CompetitionDocument
from .competitions_by_country import CompetitionsByCountry
from .countries_by_event_id import CountriesByEventId
from .current_record_holder import CurrentRecordHolder
from .disciplines_by_event_id import DisciplinesByEventId
from .enums import (
    AirQualityDeviceFilter,
    CarouselTypeEnum,
    GenderType,
    MetaDataTypes,
    OrderByEnum,
    OrderByLiveBlogPostEnum,
    OrderByNewArticleEnum,
    OrderDirectionEnum,
    PlacingTableOrderBy,
    RelatedCompetitionEnum,
    TeamStandingOrderBy,
    eventPhaseOrderByEnum,
    medalsOrderByEnum,
)
from .event_media import EventMedia
from .get_all_competitions import GetAllCompetitions
from .get_all_event_phases_by_discipline import GetAllEventPhasesByDiscipline
from .get_all_gold_tour_events import GetAllGoldTourEvents
from .get_all_time_list import GetAllTimeList
from .get_appearance import GetAppearance
from .get_article import GetArticle
from .get_article_locations import GetArticleLocations
from .get_articles import GetArticles
from .get_asset import GetAsset
from .get_assets import GetAssets
from .get_assets_dates import GetAssetsDates
from .get_assets_total import GetAssetsTotal
from .get_athlete import GetAthlete
from .get_athlete_profile_athlete_representative import (
    GetAthleteProfileAthleteRepresentative,
)
from .get_athlete_representative_athlete_search import (
    GetAthleteRepresentativeAthleteSearch,
)
from .get_athlete_representative_directory import GetAthleteRepresentativeDirectory
from .get_athlete_representative_profile import GetAthleteRepresentativeProfile
from .get_athlete_representative_top_list import GetAthleteRepresentativeTopList
from .get_athlete_results import GetAthleteResults
from .get_banners import GetBanners
from .get_c_i_s_competitor_res_date import GetCISCompetitorResDate
from .get_c_i_s_competitor_res_disp import GetCISCompetitorResDisp
from .get_c_i_s_single_competitor import GetCISSingleCompetitor
from .get_calendar_competition_results import GetCalendarCompetitionResults
from .get_calendar_events import GetCalendarEvents
from .get_campaign import GetCampaign
from .get_campaigns import GetCampaigns
from .get_carousel import GetCarousel
from .get_championship_highlights import GetChampionshipHighlights
from .get_championship_qualifications import GetChampionshipQualifications
from .get_combined_points import GetCombinedPoints
from .get_competition_organiser_info import GetCompetitionOrganiserInfo
from .get_competitor import GetCompetitor
from .get_competitor_a_a_id import GetCompetitorAAId
from .get_competitors_legacy_primary_media import GetCompetitorsLegacyPrimaryMedia
from .get_countries import GetCountries
from .get_discipline import GetDiscipline
from .get_drafted_article import GetDraftedArticle
from .get_event import GetEvent
from .get_event_broken_records import GetEventBrokenRecords
from .get_event_circuit_standings import GetEventCircuitStandings
from .get_event_leading_standings import GetEventLeadingStandings
from .get_event_phase_by_discipline import GetEventPhaseByDiscipline
from .get_event_phase_result_detail import GetEventPhaseResultDetail
from .get_event_phase_results import GetEventPhaseResults
from .get_event_phases import GetEventPhases
from .get_event_team_standing_details import GetEventTeamStandingDetails
from .get_event_team_standings import GetEventTeamStandings
from .get_event_timetable import GetEventTimetable
from .get_events import GetEvents
from .get_filter_types import GetFilterTypes
from .get_flash_interviews import GetFlashInterviews
from .get_hero_athletes_carousel import GetHeroAthletesCarousel
from .get_latest_qualified_competitors import GetLatestQualifiedCompetitors
from .get_latest_records import GetLatestRecords
from .get_leading_athletes import GetLeadingAthletes
from .get_live_blog_posts import GetLiveBlogPosts
from .get_live_combined_summary_details import GetLiveCombinedSummaryDetails
from .get_live_phase_summary import GetLivePhaseSummary
from .get_live_result import GetLiveResult
from .get_medal import GetMedal
from .get_medal_details import GetMedalDetails
from .get_medals import GetMedals
from .get_media import GetMedia
from .get_medias import GetMedias
from .get_meta_data import GetMetaData
from .get_minisite_calendar_events import GetMinisiteCalendarEvents
from .get_new_article import GetNewArticle
from .get_new_articles import GetNewArticles
from .get_new_medias import GetNewMedias
from .get_news_ticker import GetNewsTicker
from .get_on_this_day import GetOnThisDay
from .get_page import GetPage
from .get_phases import GetPhases
from .get_placing_table import GetPlacingTable
from .get_placing_table_details import GetPlacingTableDetails
from .get_pre_championship_highlights import GetPreChampionshipHighlights
from .get_random_world_ranking_discipline import GetRandomWorldRankingDiscipline
from .get_ranking_groups import GetRankingGroups
from .get_ranking_score_calculation import GetRankingScoreCalculation
from .get_recent_results import GetRecentResults
from .get_records_by_category import GetRecordsByCategory
from .get_records_disciplines import GetRecordsDisciplines
from .get_result_info import GetResultInfo
from .get_single_competitor import GetSingleCompetitor
from .get_single_competitor_all_time_personal_top10 import (
    GetSingleCompetitorAllTimePersonalTop10,
)
from .get_single_competitor_honour_summary import GetSingleCompetitorHonourSummary
from .get_single_competitor_major_championships import (
    GetSingleCompetitorMajorChampionships,
)
from .get_single_competitor_results_by_limit import GetSingleCompetitorResultsByLimit
from .get_single_competitor_results_date import GetSingleCompetitorResultsDate
from .get_single_competitor_results_discipline import (
    GetSingleCompetitorResultsDiscipline,
)
from .get_single_competitor_season_bests import GetSingleCompetitorSeasonBests
from .get_single_competitor_winning_streak import GetSingleCompetitorWinningStreak
from .get_social_carousel import GetSocialCarousel
from .get_spikes import GetSpikes
from .get_team_results import GetTeamResults
from .get_team_scoring import GetTeamScoring
from .get_top_list import GetTopList
from .get_top_lists_disciplines import GetTopListsDisciplines
from .get_top_rankings import GetTopRankings
from .get_trending_athletes import GetTrendingAthletes
from .get_upcoming_competitions import GetUpcomingCompetitions
from .get_user import GetUser
from .get_users_votes import GetUsersVotes
from .get_verification import GetVerification
from .get_video_by_id import GetVideoById
from .get_video_list import GetVideoList
from .get_video_playlist import GetVideoPlaylist
from .get_videos_total_number import GetVideosTotalNumber
from .get_vocabulary import GetVocabulary
from .get_vote_options import GetVoteOptions
from .get_waw_competition import GetWawCompetition
from .get_waw_competition_events_organizer_details import (
    GetWawCompetitionEventsOrganizerDetails,
)
from .get_waw_event import GetWawEvent
from .get_waw_event_country_list import GetWawEventCountryList
from .get_waw_medal_details import GetWawMedalDetails
from .get_waw_menu import GetWawMenu
from .get_waw_placing_table_details import GetWawPlacingTableDetails
from .get_waw_placing_tables import GetWawPlacingTables
from .get_world_leading_competitors import GetWorldLeadingCompetitors
from .get_world_ranking import GetWorldRanking
from .get_world_rankings import GetWorldRankings
from .get_world_rankings_changes import GetWorldRankingsChanges
from .head_to_head import HeadToHead
from .input_types import (
    AAapiQuery,
    CompetitorQueryInput,
    PhaseQueryInput,
    PreviousMedalQuery,
    TeamQuery,
)
from .my_athletes import MyAthletes
from .previous_medalists import PreviousMedalists
from .records_by_event import RecordsByEvent
from .results_by_athlete import ResultsByAthlete
from .search_athletes import SearchAthletes
from .search_competitors import SearchCompetitors
from .team_profile import TeamProfile
from .team_standings import TeamStandings
from .verify_captcha_token import VerifyCaptchaToken
from .verify_h_captcha_token import VerifyHCaptchaToken


def gql(q: str) -> str:
    return q


class WorldAthletics(AsyncBaseClient):
    async def get_world_ranking(self, query: AAapiQuery, field: str) -> GetWorldRanking:
        query = gql(
            """
            query GetWorldRanking($query: AAapiQuery!, $field: String!) {
              getWorldRanking(query: $query, field: $field) {
                id
                place
                worldPlace
                athlete
                athleteUrlSlug
                birthDate
                nationality
                rankingScore
                disciplines
                countryPlace
                previousId
                previousPlace
                previousRankingScore
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWorldRanking.parse_obj(data)

    async def get_ranking_groups(
        self, query: AAapiQuery, field: str
    ) -> GetRankingGroups:
        query = gql(
            """
            query GetRankingGroups($query: AAapiQuery!, $field: String!) {
              getRankingGroups(query: $query, field: $field) {
                eventGroup
                events {
                  name
                  displayName
                  gender
                  urlSlug
                  disciplineCodes
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRankingGroups.parse_obj(data)

    async def records_by_event(self, query: AAapiQuery, field: str) -> RecordsByEvent:
        query = gql(
            """
            query RecordsByEvent($query: AAapiQuery!, $field: String!) {
              recordsByEvent(query: $query, field: $field) {
                progressionListId
                category
                performance
                equal
                pending
                setIndoor
                womenOnly
                mixed
                yard
                wind
                competitor {
                  name
                  iaafId
                  urlSlug
                  birthDate
                }
                country
                venue
                date
                legend
                discipline
                disciplineNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return RecordsByEvent.parse_obj(data)

    async def get_records_disciplines(
        self, query: AAapiQuery, field: str
    ) -> GetRecordsDisciplines:
        query = gql(
            """
            query GetRecordsDisciplines($query: AAapiQuery!, $field: String!) {
              getRecordsDisciplines(query: $query, field: $field) {
                disciplineName
                disciplineCode
                typeName
                men
                women
                isRoad
                isWalk
                isWind
                isRelay
                isTrack
                isField
                isIndoor
                isOutdoor
                isCombined
                isReaction
                isValidIAAF
                order
                typeOrder
                id
                name
                hash
                typeCode
                nameUrlSlug
                typeNameUrlSlug
                updatedOn
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRecordsDisciplines.parse_obj(data)

    async def get_records_by_category(
        self, query: AAapiQuery, field: str
    ) -> GetRecordsByCategory:
        query = gql(
            """
            query GetRecordsByCategory($query: AAapiQuery!, $field: String!) {
              getRecordsByCategory(query: $query, field: $field) {
                progressionListId
                category
                performance
                equal
                pending
                setIndoor
                womenOnly
                mixed
                yard
                wind
                competitor {
                  name
                  iaafId
                  urlSlug
                  birthDate
                }
                country
                venue
                date
                legend
                discipline
                disciplineNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRecordsByCategory.parse_obj(data)

    async def current_record_holder(
        self, query: AAapiQuery, field: str
    ) -> CurrentRecordHolder:
        query = gql(
            """
            query CurrentRecordHolder($query: AAapiQuery!, $field: String!) {
              currentRecordHolder(query: $query, field: $field) {
                progressionListId
                category
                performance
                equal
                pending
                setIndoor
                womenOnly
                mixed
                yard
                wind
                competitor {
                  name
                  iaafId
                  urlSlug
                  birthDate
                }
                country
                venue
                date
                legend
                discipline
                disciplineNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return CurrentRecordHolder.parse_obj(data)

    async def get_top_list(self, query: AAapiQuery, field: str) -> GetTopList:
        query = gql(
            """
            query GetTopList($query: AAapiQuery!, $field: String!) {
              getTopList(query: $query, field: $field) {
                page
                pages
                payload {
                  position
                  place
                  achieverPosition
                  result
                  achiever
                  nationality
                  venue
                  date
                  resultScore
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTopList.parse_obj(data)

    async def get_top_lists_disciplines(
        self, query: AAapiQuery, field: str
    ) -> GetTopListsDisciplines:
        query = gql(
            """
            query GetTopListsDisciplines($query: AAapiQuery!, $field: String!) {
              getTopListsDisciplines(query: $query, field: $field) {
                disciplineName
                disciplineCode
                typeName
                men
                women
                isRoad
                isWalk
                isWind
                isRelay
                isTrack
                isField
                isIndoor
                isOutdoor
                isCombined
                isReaction
                isValidIAAF
                order
                typeOrder
                id
                name
                hash
                typeCode
                nameUrlSlug
                typeNameUrlSlug
                updatedOn
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTopListsDisciplines.parse_obj(data)

    async def get_all_time_list(self, query: AAapiQuery, field: str) -> GetAllTimeList:
        query = gql(
            """
            query GetAllTimeList($query: AAapiQuery!, $field: String!) {
              getAllTimeList(query: $query, field: $field) {
                page
                pages
                payload {
                  position
                  place
                  achieverPosition
                  result
                  achiever
                  nationality
                  venue
                  date
                  resultScore
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"query": query, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAllTimeList.parse_obj(data)

    async def get_event_broken_records(
        self, event_id: int, limit: Union[Optional[int], UnsetType] = UNSET
    ) -> GetEventBrokenRecords:
        query = gql(
            """
            query GetEventBrokenRecords($eventId: Int!, $limit: Int) {
              getEventBrokenRecords(eventId: $eventId, limit: $limit) {
                id
                phaseId
                eventId
                recordOrder
                recordTypeOrder
                competitorId_WA
                record
                sexCode
                sexName
                surname
                forename
                unitName
                areaCode
                phaseName
                phaseCode
                sexUrlSlug
                resultRank
                resultMark
                recordName
                eventId_WA
                birthDateStr
                unitTypeName
                phaseUrlSlug
                competitorId
                disciplineCode
                discipline {
                  disciplineName
                  disciplineCode
                  typeName
                  men
                  women
                  isRoad
                  isWalk
                  isWind
                  isRelay
                  isTrack
                  isField
                  isIndoor
                  isOutdoor
                  isCombined
                  isReaction
                  isValidIAAF
                  order
                  typeOrder
                  id
                  name
                  hash
                  typeCode
                  nameUrlSlug
                  typeNameUrlSlug
                  updatedOn
                }
                competitorTypeCode
                competitorCountryCode
                equalled
                updatedOn
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id, "limit": limit}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventBrokenRecords.parse_obj(data)

    async def competition_document(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        phase_id: Union[Optional[int], UnsetType] = UNSET,
        unit_id: Union[Optional[int], UnsetType] = UNSET,
        type_id: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> CompetitionDocument:
        query = gql(
            """
            query CompetitionDocument($EventId: Int, $PhaseId: Int, $UnitId: Int, $TypeId: [Int]) {
              competitionDocument(
                EventId: $EventId
                PhaseId: $PhaseId
                UnitId: $UnitId
                TypeId: $TypeId
              ) {
                eventId
                eventId_WA
                fileName
                filePath
                hash
                id
                phaseId
                typeId
                typeName
                typeOrder
                unitId
                updatedOn
              }
            }
            """
        )
        variables: dict[str, object] = {
            "EventId": event_id,
            "PhaseId": phase_id,
            "UnitId": unit_id,
            "TypeId": type_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return CompetitionDocument.parse_obj(data)

    async def get_competitor(
        self, input: Union[Optional[CompetitorQueryInput], UnsetType] = UNSET
    ) -> GetCompetitor:
        query = gql(
            """
            query GetCompetitor($input: CompetitorQueryInput) {
              getCompetitor(input: $input) {
                competitorId
                oldCompetitorId
                firstName
                lastName
                birthDate
                birthPlace
                birthCountryCode
                birthPlaceCountryName
                teamName
                countryName
                countryCode
                sexCode
                sexName
                fullBio
                butlersBio
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"input": input}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCompetitor.parse_obj(data)

    async def get_c_i_s_single_competitor(
        self,
        url_slug: str,
        id: Union[Optional[int], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> GetCISSingleCompetitor:
        query = gql(
            """
            query GetCISSingleCompetitor($id: Int, $urlSlug: String!, $ids: [Int]) {
              getCISSingleCompetitor(id: $id, urlSlug: $urlSlug, ids: $ids) {
                basicData {
                  firstName
                  lastName
                  sexName
                  countryName
                  countryCode
                  countryUrlSlug
                  birthDate
                  birthDateStr
                  butlersBio
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  iaafId
                  aaId
                }
                personalBests {
                  withWind
                  withRecords
                  results {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    linkToList
                    mark
                    combinedPerformances
                    wind
                    notLegal
                    venue
                    date
                    listPosition
                    resultScore
                  }
                }
                seasonsBests {
                  parameters {
                    seasonsBestsSeason
                  }
                  activeSeasons
                  withWind
                  withRecords
                  results {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    linkToList
                    mark
                    combinedPerformances
                    wind
                    notLegal
                    venue
                    date
                    listPosition
                    resultScore
                  }
                }
                progressionOfSeasonsBests {
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  withWind
                  mainEvent
                  results {
                    season
                    numericResult
                    mark
                    wind
                    venue
                    date
                    listPosition
                    resultScore
                  }
                }
                worldRankings {
                  parameters {
                    worldRankingsProgressionYear
                  }
                  current {
                    rankingCalculationId
                    eventGroup
                    male
                    urlSlug
                    place
                    rankingScore
                  }
                  best {
                    eventGroup
                    eventGroupId
                    urlSlug
                    place
                    weeks
                  }
                }
                honours {
                  categoryName
                  withWind
                  withDrop
                  results {
                    place
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    competition
                    venue
                    mark
                    wind
                    date
                  }
                }
                resultsByYear {
                  parameters {
                    resultsByYear
                    resultsByYearOrderBy
                  }
                  activeYears
                  resultsByEvent {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    withWind
                    withRemark
                    results {
                      date
                      competition
                      venue
                      country
                      category
                      race
                      place
                      mark
                      wind
                      notLegal
                      resultScore
                      remark
                    }
                  }
                }
                resultsByDate {
                  parameters {
                    resultsByYear
                    resultsByYearOrderBy
                  }
                  activeYears
                  withRemark
                  resultsByDate {
                    date
                    competition
                    venue
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    country
                    category
                    race
                    place
                    mark
                    wind
                    notLegal
                    resultScore
                    remark
                  }
                }
                primaryMediaId
                athleteRepresentative {
                  name
                  countryCode
                  countryName
                  email
                  telephone
                  mobile
                  repEmail
                  website
                }
                roadRaceLabelStatus {
                  year
                  labelStatus
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id, "urlSlug": url_slug, "ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCISSingleCompetitor.parse_obj(data)

    async def get_c_i_s_competitor_res_disp(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        results_by_year: Union[Optional[int], UnsetType] = UNSET,
        results_by_year_order_by: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetCISCompetitorResDisp:
        query = gql(
            """
            query GetCISCompetitorResDisp($id: Int, $resultsByYear: Int, $resultsByYearOrderBy: String) {
              getCISCompetitorResDisp(
                id: $id
                resultsByYear: $resultsByYear
                resultsByYearOrderBy: $resultsByYearOrderBy
              ) {
                parameters {
                  resultsByYear
                  resultsByYearOrderBy
                }
                activeYears
                resultsByEvent {
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  withWind
                  withRemark
                  results {
                    date
                    competition
                    venue
                    indoor
                    country
                    category
                    race
                    place
                    mark
                    wind
                    notLegal
                    resultScore
                    remark
                  }
                }
                resultsByDate {
                  date
                  competition
                  venue
                  indoor
                  country
                  category
                  race
                  place
                  mark
                  wind
                  notLegal
                  resultScore
                  remark
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "resultsByYear": results_by_year,
            "resultsByYearOrderBy": results_by_year_order_by,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCISCompetitorResDisp.parse_obj(data)

    async def get_c_i_s_competitor_res_date(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        results_by_year: Union[Optional[int], UnsetType] = UNSET,
        results_by_year_order_by: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetCISCompetitorResDate:
        query = gql(
            """
            query GetCISCompetitorResDate($id: Int, $resultsByYear: Int, $resultsByYearOrderBy: String) {
              getCISCompetitorResDate(
                id: $id
                resultsByYear: $resultsByYear
                resultsByYearOrderBy: $resultsByYearOrderBy
              ) {
                parameters {
                  resultsByYear
                  resultsByYearOrderBy
                }
                activeYears
                withRemark
                resultsByDate {
                  date
                  competition
                  venue
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  country
                  category
                  race
                  place
                  mark
                  wind
                  notLegal
                  resultScore
                  remark
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "resultsByYear": results_by_year,
            "resultsByYearOrderBy": results_by_year_order_by,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCISCompetitorResDate.parse_obj(data)

    async def get_event(self, id: str) -> GetEvent:
        query = gql(
            """
            query GetEvent($id: ID!) {
              getEvent(id: $id) {
                id
                mediaIds
                relatedMedia {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                timezone
                updatedOn
                hash
                name
                startDate
                endDate
                venue
                countryCode
                countryName
                areaCode
                areaName
                ageCode
                indoorOutdoor
                categoryCode
                categoryName
                categoryOrder
                subCategoryCode
                subCategoryName
                subCategoryOrder
                showWebLiveBanner
                eventId_WA
                classCode
                className
                classOrder
                isPublished
                hasCompDocResults
                nameUrlSlug
                startDateYear
                circuits {
                  UpdatedOn
                  hash
                  circuitCode
                  circuitTypeCode
                  circuitName
                  season
                  circuitOrder
                  circuitTypeName
                }
                areaNameUrlSlug
                categoryNameUrlSlug
                subCategoryNameUrlSlug
                disciplineCodes
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEvent.parse_obj(data)

    async def get_flash_interviews(
        self, event_id: int, is_approved: Union[Optional[bool], UnsetType] = UNSET
    ) -> GetFlashInterviews:
        query = gql(
            """
            query GetFlashInterviews($eventId: Int!, $isApproved: Boolean) {
              getFlashInterviews(eventId: $eventId, isApproved: $isApproved) {
                disciplineName
                disciplineSexName
                unitTypeName
                unitName
                phaseName
                phaseId
                unitId
                interviews {
                  id
                  phaseId
                  phaseDate
                  phaseName
                  unitId
                  unitCode
                  unitTypeName
                  unitName
                  title
                  body
                  competitorId
                  competitorTeamName
                  competitorForename
                  competitorSurname
                  competitorCountryCode
                  competitorSex
                  competitorType
                  updatedOn
                  eventId
                  disciplineCode
                  disciplineName
                  disciplineSexName
                  flashInterviewOrder
                  flashInterviewDate
                  flashInterviewHasTime
                  eventStoreId
                  isApproved
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id, "isApproved": is_approved}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetFlashInterviews.parse_obj(data)

    async def get_live_result(
        self,
        phase_id: Union[Optional[int], UnsetType] = UNSET,
        unit_id: Union[Optional[int], UnsetType] = UNSET,
        competition_id: Union[Optional[int], UnsetType] = UNSET,
        type: Union[Optional[str], UnsetType] = UNSET,
        qualified: Union[Optional[str], UnsetType] = UNSET,
        competitor_country_code: Union[Optional[str], UnsetType] = UNSET,
        competitor_type: Union[Optional[str], UnsetType] = UNSET,
        types: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
    ) -> GetLiveResult:
        query = gql(
            """
            query GetLiveResult($phaseId: Int, $unitId: Int, $competitionId: Int, $type: String, $qualified: String, $competitorCountryCode: String, $competitorType: String, $types: [String]) {
              getLiveResult(
                phaseId: $phaseId
                unitId: $unitId
                competitionId: $competitionId
                type: $type
                qualified: $qualified
                competitorCountryCode: $competitorCountryCode
                competitorType: $competitorType
                types: $types
              ) {
                type
                id
                phaseId
                unitId
                unitName
                unitType
                intermediateType
                intermediateId
                splitName
                intermediateIdType
                intermediateResultOrder
                intermediateOrder
                standingPoints
                gap
                resultId
                noStart
                lane
                seasonBestMark
                personalBestMark
                phaseSummaryOrder
                resultRanks
                summaryYank
                competitorId
                competitorForename
                competitorSurname
                competitorTeamName
                competitorCountryName
                competitorCountryCode
                competitorSex
                competitorType
                bib
                rank
                mark
                combinedPoints
                reactionTime
                record
                resultOrder
                startOrder
                qualified
                next
                last
                updatedOn
                wind
                teamName
                teamMembers {
                  phaseId
                  unitId
                  unitName
                  liveResultId
                  competitorId
                  competitorForename
                  competitorSurname
                  competitorCountryName
                  competitorCountryCode
                }
                eventStoreId
                competitionId
                resultMilliseconds
                worldRanking
              }
            }
            """
        )
        variables: dict[str, object] = {
            "phaseId": phase_id,
            "unitId": unit_id,
            "competitionId": competition_id,
            "type": type,
            "qualified": qualified,
            "competitorCountryCode": competitor_country_code,
            "competitorType": competitor_type,
            "types": types,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLiveResult.parse_obj(data)

    async def get_live_phase_summary(
        self,
        phase_id: int,
        qualified: Union[Optional[bool], UnsetType] = UNSET,
        provisional_qualifier: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetLivePhaseSummary:
        query = gql(
            """
            query GetLivePhaseSummary($phaseId: Int!, $qualified: Boolean, $provisionalQualifier: Boolean) {
              getLivePhaseSummary(
                phaseId: $phaseId
                qualified: $qualified
                provisionalQualifier: $provisionalQualifier
              ) {
                id
                phaseSummaryId
                phaseId
                unitId
                unitName
                unitType
                competitorId
                competitorTeamName
                competitorForename
                competitorSurname
                competitorCountryName
                competitorCountryCode
                competitorSex
                competitorType
                bib
                rank
                mark
                wind
                resultWind
                record
                qualified
                combinedPoints
                updatedOn
                resultRank
                phaseSummaryOrder
                provisionalQualifier
                eventStoreId
                competitionId
                reactionTime
                phaseSummaryMilliseconds
              }
            }
            """
        )
        variables: dict[str, object] = {
            "phaseId": phase_id,
            "qualified": qualified,
            "provisionalQualifier": provisional_qualifier,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLivePhaseSummary.parse_obj(data)

    async def get_live_combined_summary_details(
        self, input: Union[Optional[List[Optional[int]]], UnsetType] = UNSET
    ) -> GetLiveCombinedSummaryDetails:
        query = gql(
            """
            query GetLiveCombinedSummaryDetails($input: [Int]) {
              getLiveCombinedSummaryDetails(input: $input) {
                id
                phaseId
                competitionId
                overallRank
                bib
                competitorId
                competitorFirstName
                competitorLastName
                competitorCountryCode
                competitorBirthDate
                resultMark
                record
                detailsDiscOrder
                disciplineCode
                disciplineMark
                detailWind
                overallPoints
                overallOrder
                detailCombinedRank
                disciplineRank
                disciplinePoints
                updateOn
                combinedType
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"input": input}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLiveCombinedSummaryDetails.parse_obj(data)

    async def get_athlete_results(
        self, competition_id: int, competitor_id: int
    ) -> GetAthleteResults:
        query = gql(
            """
            query GetAthleteResults($competitionId: Int!, $competitorId: Int!) {
              getAthleteResults(competitionId: $competitionId, competitorId: $competitorId) {
                type
                id
                phaseId
                unitId
                unitName
                unitType
                intermediateType
                intermediateId
                splitName
                intermediateIdType
                intermediateResultOrder
                intermediateOrder
                standingPoints
                gap
                resultId
                noStart
                lane
                seasonBestMark
                personalBestMark
                phaseSummaryOrder
                resultRanks
                summaryYank
                competitorId
                competitorForename
                competitorSurname
                competitorTeamName
                competitorCountryName
                competitorCountryCode
                competitorSex
                competitorType
                bib
                rank
                mark
                combinedPoints
                reactionTime
                record
                resultOrder
                startOrder
                qualified
                next
                last
                updatedOn
                wind
                teamName
                teamMembers {
                  phaseId
                  unitId
                  unitName
                  liveResultId
                  competitorId
                  competitorForename
                  competitorSurname
                  competitorCountryName
                  competitorCountryCode
                }
                eventStoreId
                competitionId
                resultMilliseconds
                worldRanking
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "competitorId": competitor_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteResults.parse_obj(data)

    async def get_team_results(
        self,
        competition_id: int,
        team_id: int,
        team_sex: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetTeamResults:
        query = gql(
            """
            query GetTeamResults($competitionId: Int!, $teamId: Int!, $teamSex: String) {
              getTeamResults(
                competitionId: $competitionId
                teamId: $teamId
                teamSex: $teamSex
              ) {
                type
                id
                phaseId
                unitId
                unitName
                unitType
                intermediateType
                intermediateId
                splitName
                intermediateIdType
                intermediateResultOrder
                intermediateOrder
                standingPoints
                gap
                resultId
                noStart
                lane
                seasonBestMark
                personalBestMark
                phaseSummaryOrder
                resultRanks
                summaryYank
                competitorId
                competitorForename
                competitorSurname
                competitorTeamName
                competitorCountryName
                competitorCountryCode
                competitorSex
                competitorType
                bib
                rank
                mark
                combinedPoints
                reactionTime
                record
                resultOrder
                startOrder
                qualified
                next
                last
                updatedOn
                wind
                teamName
                teamMembers {
                  phaseId
                  unitId
                  unitName
                  liveResultId
                  competitorId
                  competitorForename
                  competitorSurname
                  competitorCountryName
                  competitorCountryCode
                }
                eventStoreId
                competitionId
                resultMilliseconds
                worldRanking
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "teamId": team_id,
            "teamSex": team_sex,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTeamResults.parse_obj(data)

    async def get_medal(self, event_id: int) -> GetMedal:
        query = gql(
            """
            query GetMedal($eventId: Int!) {
              getMedal(eventId: $eventId) {
                id
                eventId
                countryCode
                countryName
                eventMedalTableOrder
                eventSubCategoryCode
                medalRank
                bronze
                silver
                gold
                total
                updatedOn
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMedal.parse_obj(data)

    async def get_medal_details(self, medal_table_id: int) -> GetMedalDetails:
        query = gql(
            """
            query GetMedalDetails($medalTableId: Int!) {
              getMedalDetails(medalTableId: $medalTableId) {
                id
                medalTableId
                typeId
                disciplineCode
                disciplineName
                sexCode
                resultId
                resultMark
                medalDate
                detailsOrder
                competitorId
                competitorFirstName
                competitorLastName
                eventId
                phaseId
                updatedOn
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"medalTableId": medal_table_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMedalDetails.parse_obj(data)

    async def previous_medalists(
        self, input: Union[Optional[PreviousMedalQuery], UnsetType] = UNSET
    ) -> PreviousMedalists:
        query = gql(
            """
            query PreviousMedalists($input: PreviousMedalQuery) {
              previousMedalists(input: $input) {
                id
                competitorId_WA
                medalTableId
                typeId
                resultMark
                firstName
                lastName
                name
                countryCode
                countryName
                urlSlug
                countryUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"input": input}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return PreviousMedalists.parse_obj(data)

    async def event_media(
        self,
        related_event_name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        type: Union[Optional[int], UnsetType] = UNSET,
    ) -> EventMedia:
        query = gql(
            """
            query EventMedia($RelatedEventNameUrlSlug: String, $limit: Int, $offset: Int, $type: Int) {
              eventMedia(
                RelatedEventNameUrlSlug: $RelatedEventNameUrlSlug
                limit: $limit
                offset: $offset
                type: $type
              ) {
                query {
                  source
                  type
                }
                media {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "RelatedEventNameUrlSlug": related_event_name_url_slug,
            "limit": limit,
            "offset": offset,
            "type": type,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return EventMedia.parse_obj(data)

    async def get_news_ticker(self) -> GetNewsTicker:
        query = gql(
            """
            query GetNewsTicker {
              getNewsTicker {
                content
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetNewsTicker.parse_obj(data)

    async def get_phases(self, input: PhaseQueryInput) -> GetPhases:
        query = gql(
            """
            query GetPhases($input: PhaseQueryInput!) {
              getPhases(input: $input) {
                id
                phaseCode
                disciplineName
                disciplineOrder
                typeName
                typeCode
                typeOrder
                isTrack
                isField
                isRoad
                isCombined
                isWalk
                isIndoor
                isReaction
                isOutdoor
                isWind
                isRelay
                isValidIAAF
                isInLane
                hasReactionTimes
                hasWindMeasurement
                inoutCode
                hasTeamStanding
                discCodeGroup
                phaseName
                eventId
                phaseDateAndTime
                sexCode
                sexName
                disciplineCode
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionOrder
                phaseSessionName
                primaryPhaseOrder
                status
                hasTime
                updatedOn
                units {
                  id
                  phaseId
                  unitName
                  unitType
                  unitOrder
                  isStartlistPublished
                  isResultPublished
                  isPhaseSummaryPublished
                  isTeamStandingPublished
                  combinedDisciplineOrder
                  status
                  qualificationRuleCode
                  updatedOn
                  startDate
                  startTime
                  startDateTime
                  wind
                }
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"input": input}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetPhases.parse_obj(data)

    async def get_placing_table(self, event_id: int) -> GetPlacingTable:
        query = gql(
            """
            query GetPlacingTable($eventId: Int!) {
              getPlacingTable(eventId: $eventId) {
                id
                eventId
                rank
                countryName
                countryCode
                gold
                silver
                bronze
                forth
                fifth
                sixth
                seventh
                eighth
                points
                tableOrder
                subCategoryCode
                updatedOn
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetPlacingTable.parse_obj(data)

    async def get_placing_table_details(
        self, placing_table_id: int
    ) -> GetPlacingTableDetails:
        query = gql(
            """
            query GetPlacingTableDetails($placingTableId: Int!) {
              getPlacingTableDetails(placingTableId: $placingTableId) {
                id
                placingTableId
                competitorId
                disciplineCode
                disciplineName
                competitorFirstName
                competitorLastName
                sexCode
                placingDate
                detailsOrder
                eventId
                typeId
                typeName
                typeAbbreviation
                resultMark
                placingPoints
                resultId
                phaseId
                countryCode
                updatedOn
                eventStoreId
              }
            }
            """
        )
        variables: dict[str, object] = {"placingTableId": placing_table_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetPlacingTableDetails.parse_obj(data)

    async def team_profile(self, input: TeamQuery, field: str) -> TeamProfile:
        query = gql(
            """
            query TeamProfile($input: TeamQuery!, $field: String!) {
              teamProfile(input: $input, field: $field) {
                personalBestInfo {
                  id
                  IndoorOutdoor
                }
                personalBests {
                  id
                  competitorId
                  updatedOn
                  resultDate
                  hash
                  bestTypeCode
                  bestTypeName
                  season
                  bestOrder
                  bestTypeOrder
                  bestSubTypeOrder
                  indoorOutdoor
                  resultId
                  resultWind
                  resultVenue
                  resultMark
                  discipline {
                    _id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                }
                personalHonourInfo {
                  id
                }
                personalHonour {
                  id
                  competitorId
                  resultId
                  eventId
                  hash
                  eventName
                  eventCategoryName
                  eventSubCategoryName
                  updatedOn
                  eventStartDate
                  eventEndDate
                  resultDate
                  resultMark
                  resultVenue
                  resultRankDetail
                  eventCategoryNameUrlSlug
                  eventSubCategoryNameUrlSlug
                  eventNameUrlSlug
                  honourOrder
                  honourTypeOrder
                  discipline {
                    _id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"input": input, "field": field}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return TeamProfile.parse_obj(data)

    async def get_team_scoring(
        self,
        phase_id: int,
        type: str,
        team_country_code: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetTeamScoring:
        query = gql(
            """
            query GetTeamScoring($phaseId: Int!, $type: String!, $teamCountryCode: String) {
              getTeamScoring(
                phaseId: $phaseId
                type: $type
                teamCountryCode: $teamCountryCode
              ) {
                id
                teamId
                teamId_WA
                phaseId
                unitId
                resultId
                teamName
                teamCountryCode
                competitorId
                athlete {
                  competitorId
                  detail {
                    id
                    updatedOn
                    hash
                    typeCode
                    firstName
                    lastName
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDateStr
                    urlSlug
                    representativeId
                    name
                    countryUrlSlug
                    sexNameUrlSlug
                    friendlyName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                  }
                  firstName
                  lastName
                  birthDate
                  birthPlace
                  birthCountryCode
                  birthPlaceCountryName
                  teamName
                  countryName
                  countryCode
                  sexCode
                  sexName
                }
                updatedOn
                scoringTeamId
                scoringTeamOrder
                scoringTeamDetailOrder
                bib
                eventStoreId
                chunkOrder
                chunkId
              }
            }
            """
        )
        variables: dict[str, object] = {
            "phaseId": phase_id,
            "type": type,
            "teamCountryCode": team_country_code,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTeamScoring.parse_obj(data)

    async def team_standings(
        self,
        unit_id: int,
        type: str,
        team_country_code: Union[Optional[str], UnsetType] = UNSET,
        competition_intermediate_order: Union[Optional[int], UnsetType] = UNSET,
    ) -> TeamStandings:
        query = gql(
            """
            query TeamStandings($unitId: Int!, $type: String!, $teamCountryCode: String, $competitionIntermediateOrder: Int) {
              teamStandings(
                unitId: $unitId
                type: $type
                teamCountryCode: $teamCountryCode
                competitionIntermediateOrder: $competitionIntermediateOrder
              ) {
                id
                phaseId
                unitId
                type
                competitionIntermediateId
                competitionIntermediateName
                rank
                teamId
                teamId_WA
                teamName
                teamCountryCode
                standingMark
                liveCurrent
                updatedOn
                teamStandingId
                competitionIntermediateOrder
                detailRank
                standingDetailBib
                competitorId
                relatedAthlete {
                  competitorId
                  detail {
                    id
                    updatedOn
                    hash
                    typeCode
                    firstName
                    lastName
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDateStr
                    urlSlug
                    representativeId
                    name
                    countryUrlSlug
                    sexNameUrlSlug
                    friendlyName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                  }
                  firstName
                  lastName
                  birthDate
                  birthPlace
                  birthCountryCode
                  birthPlaceCountryName
                  teamName
                  countryName
                  countryCode
                  sexCode
                  sexName
                }
                standingDetailScore
                standingDetailScoring
                teamStandingOrder
                teamStandingDetailOrder
                eventStoreId
                chunkOrder
                chunkId
              }
            }
            """
        )
        variables: dict[str, object] = {
            "unitId": unit_id,
            "type": type,
            "teamCountryCode": team_country_code,
            "competitionIntermediateOrder": competition_intermediate_order,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return TeamStandings.parse_obj(data)

    async def get_campaigns(self) -> GetCampaigns:
        query = gql(
            """
            query GetCampaigns {
              getCampaigns {
                id
                value
                key
                type
                description
                thankYouMessage
                alreadySignedMessage
                closeDate
                redirectUrl
                tagUserFriendlyName
                deleted
                visibleOnPreferenceCenter
                shortForm
                topLevelBucketId
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCampaigns.parse_obj(data)

    async def get_campaign(self, tag: str) -> GetCampaign:
        query = gql(
            """
            query GetCampaign($tag: String!) {
              getCampaign(tag: $tag) {
                id
                name
                tag
                type
                description
                thankYouMessage
                alreadySignedMessage
                closeDate
                redirectUrl
                tagUserFriendlyName
                backgroundImageEdited
                headerImageEdited
                visibleOnPreferenceCenter
                shortForm
                topLevelBucketId
              }
            }
            """
        )
        variables: dict[str, object] = {"tag": tag}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCampaign.parse_obj(data)

    async def verify_captcha_token(self, token: str) -> VerifyCaptchaToken:
        query = gql(
            """
            query VerifyCaptchaToken($token: String!) {
              verifyCaptchaToken(token: $token) {
                isSuccess
                errorCodes
                hostname
              }
            }
            """
        )
        variables: dict[str, object] = {"token": token}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return VerifyCaptchaToken.parse_obj(data)

    async def verify_h_captcha_token(self, token: str) -> VerifyHCaptchaToken:
        query = gql(
            """
            query VerifyHCaptchaToken($token: String!) {
              verifyHCaptchaToken(token: $token) {
                isSuccess
                errorCodes
                hostname
              }
            }
            """
        )
        variables: dict[str, object] = {"token": token}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return VerifyHCaptchaToken.parse_obj(data)

    async def get_user(self) -> GetUser:
        query = gql(
            """
            query GetUser {
              getUser {
                cognitoId
                registrationDate
                dateModified
                name
                settings {
                  firstName
                  lastName
                  email
                  ageGroup
                  sex
                  countryCode
                  nationalTeamSupportCountryCode
                  mailingListConsent
                  kidsAthleticsTermsAndConditions
                  userTypes
                  userSubTypes
                  disciplineCategories
                  interests
                  contactPreferences
                  source
                  tags
                  followedCompetitors
                }
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetUser.parse_obj(data)

    async def get_verification(self) -> GetVerification:
        query = gql(
            """
            query GetVerification {
              getVerification {
                confirmationCode
                username
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVerification.parse_obj(data)

    async def get_latest_records(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        days: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetLatestRecords:
        query = gql(
            """
            query GetLatestRecords($limit: Int, $days: Int) {
              getLatestRecords(limit: $limit, days: $days) {
                moduleTitle
                moduleSubtitle
                records {
                  recordType
                  mark
                  eventName
                  competitor {
                    name
                    id
                    urlSlug
                    countryUrlSlug
                    birthDate
                    teamMembers {
                      id
                      name
                      iaafId
                      urlSlug
                    }
                  }
                  date
                  location
                  countryName
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit, "days": days}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLatestRecords.parse_obj(data)

    async def air_quality_devices(
        self, filter: Union[Optional[AirQualityDeviceFilter], UnsetType] = UNSET
    ) -> AirQualityDevices:
        query = gql(
            """
            query AirQualityDevices($filter: AirQualityDeviceFilter) {
              airQualityDevices(filter: $filter) {
                serial_number
                tag
                status
                last_connection_ts
                location {
                  latitude
                  longitude
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"filter": filter}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return AirQualityDevices.parse_obj(data)

    async def air_quality_device_element_reads(
        self,
        device_id: str,
        element_id: str,
        from_: Any,
        number: Union[Optional[int], UnsetType] = UNSET,
    ) -> AirQualityDeviceElementReads:
        query = gql(
            """
            query AirQualityDeviceElementReads($deviceId: String!, $elementId: String!, $from: AWSDateTime!, $number: Int) {
              airQualityDeviceElementReads(
                deviceId: $deviceId
                elementId: $elementId
                from: $from
                number: $number
              ) {
                value
                validation
                reason
                ts
              }
            }
            """
        )
        variables: dict[str, object] = {
            "deviceId": device_id,
            "elementId": element_id,
            "from": from_,
            "number": number,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return AirQualityDeviceElementReads.parse_obj(data)

    async def get_appearance(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        competition_id: Union[Optional[str], UnsetType] = UNSET,
        site_id: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetAppearance:
        query = gql(
            """
            query GetAppearance($eventId: Int, $competitionId: String, $siteId: String) {
              getAppearance(eventId: $eventId, competitionId: $competitionId, siteId: $siteId) {
                id
                name
                logoId
                logo {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                logoEdited
                featureImageId
                featureImage {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                featureImageEdited
                theme
                defaultSponsorIds
                defaultSponsors {
                  id
                  eventId
                  type
                  name
                  url
                  logoScale
                  lightBgLogoId
                  lightBgLogo {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  lightBgLogoEdited
                  darkBgLogoId
                  darkBgLogo {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  darkBgLogoEdited
                }
                sponsorIds
                sponsors {
                  id
                  eventId
                  type
                  name
                  url
                  logoScale
                  lightBgLogoId
                  lightBgLogo {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  lightBgLogoEdited
                  darkBgLogoId
                  darkBgLogo {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  darkBgLogoEdited
                }
                eventId
                primaryColor
                secondaryColor
                tertiaryColor
                additionalColours
                languageCodes
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "competitionId": competition_id,
            "siteId": site_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAppearance.parse_obj(data)

    async def get_articles(
        self,
        ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_event_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_article_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        types: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        order_by: Union[Optional[OrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        related_competition: Union[Optional[RelatedCompetitionEnum], UnsetType] = UNSET,
        related_competitor_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_competition_ids: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_discipline_type_name_urls_slugs: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_event_name_url_slug: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
    ) -> GetArticles:
        query = gql(
            """
            query GetArticles($ids: [String], $RelatedEventIds: [Int], $RelatedArticleIds: [Int], $types: [Int], $orderBy: OrderByEnum, $orderDirection: OrderDirectionEnum, $limit: Int, $offset: Int, $relatedCompetition: RelatedCompetitionEnum, $RelatedCompetitorIds: [Int], $relatedCompetitionIds: [String], $RelatedDisciplineTypeNameUrlsSlugs: [String], $RelatedEventNameUrlSlug: [String]) {
              getArticles(
                ids: $ids
                RelatedEventIds: $RelatedEventIds
                RelatedArticleIds: $RelatedArticleIds
                types: $types
                orderBy: $orderBy
                orderDirection: $orderDirection
                limit: $limit
                offset: $offset
                relatedCompetition: $relatedCompetition
                RelatedCompetitorIds: $RelatedCompetitorIds
                relatedCompetitionIds: $relatedCompetitionIds
                RelatedDisciplineTypeNameUrlsSlugs: $RelatedDisciplineTypeNameUrlsSlugs
                RelatedEventNameUrlSlug: $RelatedEventNameUrlSlug
              ) {
                id
                title
                location {
                  name
                }
                body
                standFirst
                metaDescription
                sEOTitle
                urlSlug
                plainTextBody
                authorIds
                competitorAuthorId
                articleType
                featured
                featuredOrder
                status
                liveFrom
                createdOn
                updatedOn
                liveFromDay
                liveFromMonth
                liveFromYear
                relatedMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                relatedMediaIds
                relatedArticles {
                  id
                  title
                  location {
                    name
                  }
                  body
                  standFirst
                  metaDescription
                  sEOTitle
                  urlSlug
                  plainTextBody
                  authorIds
                  competitorAuthorId
                  articleType
                  featured
                  featuredOrder
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  liveFromDay
                  liveFromMonth
                  liveFromYear
                  relatedMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  relatedMediaIds
                  relatedArticles {
                    id
                    title
                    location {
                      name
                    }
                    body
                    standFirst
                    metaDescription
                    sEOTitle
                    urlSlug
                    plainTextBody
                    authorIds
                    competitorAuthorId
                    articleType
                    featured
                    featuredOrder
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    liveFromDay
                    liveFromMonth
                    liveFromYear
                    relatedMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    relatedMediaIds
                    relatedArticles {
                      id
                      title
                      body
                      standFirst
                      metaDescription
                      sEOTitle
                      urlSlug
                      plainTextBody
                      authorIds
                      competitorAuthorId
                      articleType
                      featured
                      featuredOrder
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      liveFromDay
                      liveFromMonth
                      liveFromYear
                      relatedMediaIds
                      relatedArticleIds
                      relatedDisciplineCodes
                      relatedCompetitorIds
                      relatedCompetitionIds
                      relatedDisciplineTypeNameUrlsSlugs
                      relatedEventIds
                      relatedLinks
                      relatedDocumentIds
                      relatedSpikesArticleIds
                      relatedMinisiteIds
                      tags
                      gatedContent
                    }
                    relatedArticleIds
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedDisciplineCodes
                    relatedCompetitors {
                      id
                      mediaIds
                      updatedOn
                      hash
                      typeCode
                      firstName
                      lastName
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDateStr
                      urlSlug
                      representativeId
                      competitorId_WA
                      name
                      countryUrlSlug
                      sexNameUrlSlug
                      friendlyName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                    }
                    relatedCompetitorIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedCompetitionIds
                    relatedDisciplineTypeNameUrlsSlugs
                    relatedEventIds
                    relatedLinks
                    relatedDocumentIds
                    relatedSpikesArticleIds
                    relatedMinisiteIds
                    tags
                    gatedContent
                  }
                  relatedArticleIds
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  relatedDisciplineCodes
                  relatedCompetitors {
                    id
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    updatedOn
                    hash
                    typeCode
                    firstName
                    lastName
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDateStr
                    urlSlug
                    representativeId
                    competitorId_WA
                    name
                    countryUrlSlug
                    sexNameUrlSlug
                    friendlyName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                  }
                  relatedCompetitorIds
                  relatedCompetitions {
                    id
                    name
                    circuitTypeCode
                    eventSubCategoryCode
                    description
                    circuitCode
                    urlSlug
                    order
                    category
                    about
                    primaryMediaId
                    relatedMediaIds
                    logoLightId
                    logoDarkId
                    styleOverrides
                    relatedInfo
                    nextEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    lastEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    nextEventStartDate
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  relatedCompetitionIds
                  relatedDisciplineTypeNameUrlsSlugs
                  relatedEventIds
                  relatedLinks
                  relatedDocumentIds
                  relatedSpikesArticleIds
                  relatedMinisiteIds
                  tags
                  gatedContent
                }
                relatedArticleIds
                relatedDiscipline {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                relatedDisciplineCodes
                relatedCompetitors {
                  id
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  updatedOn
                  hash
                  typeCode
                  firstName
                  lastName
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDateStr
                  urlSlug
                  representativeId
                  competitorId_WA
                  name
                  countryUrlSlug
                  sexNameUrlSlug
                  friendlyName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                }
                relatedCompetitorIds
                relatedCompetitions {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                relatedCompetitionIds
                relatedDisciplineTypeNameUrlsSlugs
                relatedEventIds
                relatedLinks
                relatedDocumentIds
                relatedSpikesArticleIds
                relatedMinisiteIds
                tags
                gatedContent
              }
            }
            """
        )
        variables: dict[str, object] = {
            "ids": ids,
            "RelatedEventIds": related_event_ids,
            "RelatedArticleIds": related_article_ids,
            "types": types,
            "orderBy": order_by,
            "orderDirection": order_direction,
            "limit": limit,
            "offset": offset,
            "relatedCompetition": related_competition,
            "RelatedCompetitorIds": related_competitor_ids,
            "relatedCompetitionIds": related_competition_ids,
            "RelatedDisciplineTypeNameUrlsSlugs": related_discipline_type_name_urls_slugs,
            "RelatedEventNameUrlSlug": related_event_name_url_slug,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetArticles.parse_obj(data)

    async def get_article(self, url_slug: str) -> GetArticle:
        query = gql(
            """
            query GetArticle($urlSlug: String!) {
              getArticle(urlSlug: $urlSlug) {
                id
                title
                location {
                  name
                }
                body
                standFirst
                metaDescription
                sEOTitle
                urlSlug
                plainTextBody
                authorIds
                competitorAuthorId
                articleType
                featured
                featuredOrder
                status
                liveFrom
                createdOn
                updatedOn
                liveFromDay
                liveFromMonth
                liveFromYear
                relatedMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                relatedMediaIds
                relatedArticles {
                  id
                  title
                  location {
                    name
                  }
                  body
                  standFirst
                  metaDescription
                  sEOTitle
                  urlSlug
                  plainTextBody
                  authorIds
                  competitorAuthorId
                  articleType
                  featured
                  featuredOrder
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  liveFromDay
                  liveFromMonth
                  liveFromYear
                  relatedMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  relatedMediaIds
                  relatedArticles {
                    id
                    title
                    location {
                      name
                    }
                    body
                    standFirst
                    metaDescription
                    sEOTitle
                    urlSlug
                    plainTextBody
                    authorIds
                    competitorAuthorId
                    articleType
                    featured
                    featuredOrder
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    liveFromDay
                    liveFromMonth
                    liveFromYear
                    relatedMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    relatedMediaIds
                    relatedArticles {
                      id
                      title
                      body
                      standFirst
                      metaDescription
                      sEOTitle
                      urlSlug
                      plainTextBody
                      authorIds
                      competitorAuthorId
                      articleType
                      featured
                      featuredOrder
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      liveFromDay
                      liveFromMonth
                      liveFromYear
                      relatedMediaIds
                      relatedArticleIds
                      relatedDisciplineCodes
                      relatedCompetitorIds
                      relatedCompetitionIds
                      relatedDisciplineTypeNameUrlsSlugs
                      relatedEventIds
                      relatedLinks
                      relatedDocumentIds
                      relatedSpikesArticleIds
                      relatedMinisiteIds
                      tags
                      gatedContent
                    }
                    relatedArticleIds
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedDisciplineCodes
                    relatedCompetitors {
                      id
                      mediaIds
                      updatedOn
                      hash
                      typeCode
                      firstName
                      lastName
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDateStr
                      urlSlug
                      representativeId
                      competitorId_WA
                      name
                      countryUrlSlug
                      sexNameUrlSlug
                      friendlyName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                    }
                    relatedCompetitorIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedCompetitionIds
                    relatedDisciplineTypeNameUrlsSlugs
                    relatedEventIds
                    relatedLinks
                    relatedDocumentIds
                    relatedSpikesArticleIds
                    relatedMinisiteIds
                    tags
                    gatedContent
                  }
                  relatedArticleIds
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  relatedDisciplineCodes
                  relatedCompetitors {
                    id
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    updatedOn
                    hash
                    typeCode
                    firstName
                    lastName
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDateStr
                    urlSlug
                    representativeId
                    competitorId_WA
                    name
                    countryUrlSlug
                    sexNameUrlSlug
                    friendlyName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                  }
                  relatedCompetitorIds
                  relatedCompetitions {
                    id
                    name
                    circuitTypeCode
                    eventSubCategoryCode
                    description
                    circuitCode
                    urlSlug
                    order
                    category
                    about
                    primaryMediaId
                    relatedMediaIds
                    logoLightId
                    logoDarkId
                    styleOverrides
                    relatedInfo
                    nextEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    lastEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    nextEventStartDate
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  relatedCompetitionIds
                  relatedDisciplineTypeNameUrlsSlugs
                  relatedEventIds
                  relatedLinks
                  relatedDocumentIds
                  relatedSpikesArticleIds
                  relatedMinisiteIds
                  tags
                  gatedContent
                }
                relatedArticleIds
                relatedDiscipline {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                relatedDisciplineCodes
                relatedCompetitors {
                  id
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  updatedOn
                  hash
                  typeCode
                  firstName
                  lastName
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDateStr
                  urlSlug
                  representativeId
                  competitorId_WA
                  name
                  countryUrlSlug
                  sexNameUrlSlug
                  friendlyName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                }
                relatedCompetitorIds
                relatedCompetitions {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                relatedCompetitionIds
                relatedDisciplineTypeNameUrlsSlugs
                relatedEventIds
                relatedLinks
                relatedDocumentIds
                relatedSpikesArticleIds
                relatedMinisiteIds
                tags
                gatedContent
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetArticle.parse_obj(data)

    async def get_new_articles(
        self,
        language: Union[Optional[str], UnsetType] = UNSET,
        order_by: Union[Optional[OrderByNewArticleEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        related_event_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_competition_ids: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_discipline_url_slug: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_discipline_codes: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_athlete_url_slug: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_athlete_ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_competition_url_slug: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        types: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_event_name_url_slug: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        related_minisite_ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_location_ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_country_codes: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_region_codes: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        tags: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        filter_article_slug: Union[Optional[str], UnsetType] = UNSET,
        check_hidden_on_main_site: Union[Optional[bool], UnsetType] = UNSET,
        published_year: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetNewArticles:
        query = gql(
            """
            query GetNewArticles($language: String, $orderBy: OrderByNewArticleEnum, $orderDirection: OrderDirectionEnum, $limit: Int, $offset: Int, $relatedEventIds: [Int], $relatedCompetitionIds: [String], $relatedDisciplineUrlSlug: [String], $relatedDisciplineCodes: [String], $relatedAthleteUrlSlug: [String], $relatedAthleteIds: [String], $relatedCompetitionUrlSlug: [String], $types: [Int], $relatedEventNameUrlSlug: [String], $relatedMinisiteIds: [String], $relatedLocationIds: [String], $relatedCountryCodes: [String], $relatedRegionCodes: [String], $tags: [String], $filterArticleSlug: String, $checkHiddenOnMainSite: Boolean, $publishedYear: String) {
              getNewArticles(
                language: $language
                orderBy: $orderBy
                orderDirection: $orderDirection
                limit: $limit
                offset: $offset
                relatedEventIds: $relatedEventIds
                relatedCompetitionIds: $relatedCompetitionIds
                relatedDisciplineUrlSlug: $relatedDisciplineUrlSlug
                relatedDisciplineCodes: $relatedDisciplineCodes
                relatedAthleteUrlSlug: $relatedAthleteUrlSlug
                relatedAthleteIds: $relatedAthleteIds
                relatedCompetitionUrlSlug: $relatedCompetitionUrlSlug
                types: $types
                relatedEventNameUrlSlug: $relatedEventNameUrlSlug
                relatedMinisiteIds: $relatedMinisiteIds
                relatedLocationIds: $relatedLocationIds
                relatedCountryCodes: $relatedCountryCodes
                relatedRegionCodes: $relatedRegionCodes
                tags: $tags
                filterArticleSlug: $filterArticleSlug
                checkHiddenOnMainSite: $checkHiddenOnMainSite
                publishedYear: $publishedYear
              ) {
                id
                title
                body
                contentId
                standFirst
                standfirst
                backgroundColour
                seoDescription
                sEOTitle
                seoTitle
                urlSlug
                slug
                campaignId
                relatedUrls
                liveFrom
                articleType
                featureImageId
                featureImageEdited
                hideOnTheMainSite
                imageEdited
                mediaIds
                relatedMedia {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                eventId
                event {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                blogUpdated
                liveBlog
                language
                relatedCompetitorIds
                relatedCompetitors {
                  id
                  iaafId
                  firstName
                  lastName
                  friendlyName
                  fullName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthPlace
                  birthPlaceCountryName
                  sexNameUrlSlug
                  countryUrlSlug
                  birthPlaceCountryUrlSlug
                  birthCountryCode
                  primaryMediaId
                  primaryMediaEdited
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  transfersOfAllegiance
                  aaId
                  countryFullName
                  familyName
                  givenName
                  birthDateStr
                  facebookUsername
                  twitterUsername
                  instagramUsername
                  mediaIds
                }
                relatedDisciplineCodes
                relatedDiscipline {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                relatedCompetitionIds
                relatedCompetitions {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                relatedEventIds
                relatedEvents {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                relatedArticleIds
                relatedArticles {
                  id
                  title
                  body
                  contentId
                  standFirst
                  standfirst
                  backgroundColour
                  seoDescription
                  sEOTitle
                  seoTitle
                  urlSlug
                  slug
                  campaignId
                  relatedUrls
                  liveFrom
                  articleType
                  featureImageId
                  featureImageEdited
                  hideOnTheMainSite
                  imageEdited
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  blogUpdated
                  liveBlog
                  language
                  relatedCompetitorIds
                  relatedCompetitors {
                    id
                    iaafId
                    firstName
                    lastName
                    friendlyName
                    fullName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDate
                    birthPlace
                    birthPlaceCountryName
                    sexNameUrlSlug
                    countryUrlSlug
                    birthPlaceCountryUrlSlug
                    birthCountryCode
                    primaryMediaId
                    primaryMediaEdited
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    urlSlug
                    representativeId
                    biography
                    twitterLink
                    instagramLink
                    facebookLink
                    transfersOfAllegiance
                    aaId
                    countryFullName
                    familyName
                    givenName
                    birthDateStr
                    facebookUsername
                    twitterUsername
                    instagramUsername
                    mediaIds
                  }
                  relatedDisciplineCodes
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  relatedCompetitionIds
                  relatedCompetitions {
                    id
                    name
                    circuitTypeCode
                    eventSubCategoryCode
                    description
                    circuitCode
                    urlSlug
                    order
                    category
                    about
                    primaryMediaId
                    relatedMediaIds
                    logoLightId
                    logoDarkId
                    styleOverrides
                    relatedInfo
                    nextEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    lastEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    nextEventStartDate
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  relatedEventIds
                  relatedEvents {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  relatedArticleIds
                  relatedArticles {
                    id
                    title
                    body
                    contentId
                    standFirst
                    standfirst
                    backgroundColour
                    seoDescription
                    sEOTitle
                    seoTitle
                    urlSlug
                    slug
                    campaignId
                    relatedUrls
                    liveFrom
                    articleType
                    featureImageId
                    featureImageEdited
                    hideOnTheMainSite
                    imageEdited
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    blogUpdated
                    liveBlog
                    language
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedCompetitionIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedEventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    relatedMinisiteIds
                    relatedMinisitePages {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    relatedCountryCodes
                    relatedRegionCodes
                    tags
                    relatedLinks {
                      displayText
                      url
                    }
                    published
                    columns
                    publishedById
                    publishedByName
                    relatedArticlesBackgroundColor
                    contentModules {
                      moduleType
                      title
                      backgroundColor
                      layout
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                  }
                  relatedMinisiteIds
                  relatedMinisitePages {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  relatedCountryCodes
                  relatedRegionCodes
                  tags
                  relatedLinks {
                    displayText
                    url
                  }
                  published
                  columns
                  publishedById
                  publishedByName
                  relatedArticlesBackgroundColor
                  contentModules {
                    moduleType
                    title
                    backgroundColor
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    layout
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                }
                relatedMinisiteIds
                relatedMinisitePages {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
                relatedCountryCodes
                relatedRegionCodes
                tags
                relatedLinks {
                  displayText
                  url
                }
                published
                columns
                publishedById
                publishedByName
                relatedArticlesBackgroundColor
                contentModules {
                  moduleType
                  title
                  backgroundColor
                  locations {
                    locationId
                    location {
                      id
                      name
                      latitude
                      longitude
                    }
                    headline
                    description
                    link
                    imageId
                    imageEdited
                  }
                  layout
                  videoIds
                  videoPlaylistId
                  relatedVideos {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                  videoId
                  relatedVideo {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                }
                gatedContent
              }
            }
            """
        )
        variables: dict[str, object] = {
            "language": language,
            "orderBy": order_by,
            "orderDirection": order_direction,
            "limit": limit,
            "offset": offset,
            "relatedEventIds": related_event_ids,
            "relatedCompetitionIds": related_competition_ids,
            "relatedDisciplineUrlSlug": related_discipline_url_slug,
            "relatedDisciplineCodes": related_discipline_codes,
            "relatedAthleteUrlSlug": related_athlete_url_slug,
            "relatedAthleteIds": related_athlete_ids,
            "relatedCompetitionUrlSlug": related_competition_url_slug,
            "types": types,
            "relatedEventNameUrlSlug": related_event_name_url_slug,
            "relatedMinisiteIds": related_minisite_ids,
            "relatedLocationIds": related_location_ids,
            "relatedCountryCodes": related_country_codes,
            "relatedRegionCodes": related_region_codes,
            "tags": tags,
            "filterArticleSlug": filter_article_slug,
            "checkHiddenOnMainSite": check_hidden_on_main_site,
            "publishedYear": published_year,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetNewArticles.parse_obj(data)

    async def get_new_article(
        self, url_slug: str, language: Union[Optional[str], UnsetType] = UNSET
    ) -> GetNewArticle:
        query = gql(
            """
            query GetNewArticle($urlSlug: String!, $language: String) {
              getNewArticle(urlSlug: $urlSlug, language: $language) {
                id
                title
                body
                contentId
                standFirst
                standfirst
                backgroundColour
                seoDescription
                sEOTitle
                seoTitle
                urlSlug
                slug
                campaignId
                relatedUrls
                liveFrom
                articleType
                featureImageId
                featureImageEdited
                hideOnTheMainSite
                imageEdited
                mediaIds
                relatedMedia {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                eventId
                event {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                blogUpdated
                liveBlog
                language
                relatedCompetitorIds
                relatedCompetitors {
                  id
                  iaafId
                  firstName
                  lastName
                  friendlyName
                  fullName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthPlace
                  birthPlaceCountryName
                  sexNameUrlSlug
                  countryUrlSlug
                  birthPlaceCountryUrlSlug
                  birthCountryCode
                  primaryMediaId
                  primaryMediaEdited
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  transfersOfAllegiance
                  aaId
                  countryFullName
                  familyName
                  givenName
                  birthDateStr
                  facebookUsername
                  twitterUsername
                  instagramUsername
                  mediaIds
                }
                relatedDisciplineCodes
                relatedDiscipline {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                relatedCompetitionIds
                relatedCompetitions {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                relatedEventIds
                relatedEvents {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                relatedArticleIds
                relatedArticles {
                  id
                  title
                  body
                  contentId
                  standFirst
                  standfirst
                  backgroundColour
                  seoDescription
                  sEOTitle
                  seoTitle
                  urlSlug
                  slug
                  campaignId
                  relatedUrls
                  liveFrom
                  articleType
                  featureImageId
                  featureImageEdited
                  hideOnTheMainSite
                  imageEdited
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  blogUpdated
                  liveBlog
                  language
                  relatedCompetitorIds
                  relatedCompetitors {
                    id
                    iaafId
                    firstName
                    lastName
                    friendlyName
                    fullName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDate
                    birthPlace
                    birthPlaceCountryName
                    sexNameUrlSlug
                    countryUrlSlug
                    birthPlaceCountryUrlSlug
                    birthCountryCode
                    primaryMediaId
                    primaryMediaEdited
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    urlSlug
                    representativeId
                    biography
                    twitterLink
                    instagramLink
                    facebookLink
                    transfersOfAllegiance
                    aaId
                    countryFullName
                    familyName
                    givenName
                    birthDateStr
                    facebookUsername
                    twitterUsername
                    instagramUsername
                    mediaIds
                  }
                  relatedDisciplineCodes
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  relatedCompetitionIds
                  relatedCompetitions {
                    id
                    name
                    circuitTypeCode
                    eventSubCategoryCode
                    description
                    circuitCode
                    urlSlug
                    order
                    category
                    about
                    primaryMediaId
                    relatedMediaIds
                    logoLightId
                    logoDarkId
                    styleOverrides
                    relatedInfo
                    nextEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    lastEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    nextEventStartDate
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  relatedEventIds
                  relatedEvents {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  relatedArticleIds
                  relatedArticles {
                    id
                    title
                    body
                    contentId
                    standFirst
                    standfirst
                    backgroundColour
                    seoDescription
                    sEOTitle
                    seoTitle
                    urlSlug
                    slug
                    campaignId
                    relatedUrls
                    liveFrom
                    articleType
                    featureImageId
                    featureImageEdited
                    hideOnTheMainSite
                    imageEdited
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    blogUpdated
                    liveBlog
                    language
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedCompetitionIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedEventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    relatedMinisiteIds
                    relatedMinisitePages {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    relatedCountryCodes
                    relatedRegionCodes
                    tags
                    relatedLinks {
                      displayText
                      url
                    }
                    published
                    columns
                    publishedById
                    publishedByName
                    relatedArticlesBackgroundColor
                    contentModules {
                      moduleType
                      title
                      backgroundColor
                      layout
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                  }
                  relatedMinisiteIds
                  relatedMinisitePages {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  relatedCountryCodes
                  relatedRegionCodes
                  tags
                  relatedLinks {
                    displayText
                    url
                  }
                  published
                  columns
                  publishedById
                  publishedByName
                  relatedArticlesBackgroundColor
                  contentModules {
                    moduleType
                    title
                    backgroundColor
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    layout
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                }
                relatedMinisiteIds
                relatedMinisitePages {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
                relatedCountryCodes
                relatedRegionCodes
                tags
                relatedLinks {
                  displayText
                  url
                }
                published
                columns
                publishedById
                publishedByName
                relatedArticlesBackgroundColor
                contentModules {
                  moduleType
                  title
                  backgroundColor
                  locations {
                    locationId
                    location {
                      id
                      name
                      latitude
                      longitude
                    }
                    headline
                    description
                    link
                    imageId
                    imageEdited
                  }
                  layout
                  videoIds
                  videoPlaylistId
                  relatedVideos {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                  videoId
                  relatedVideo {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                }
                gatedContent
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug, "language": language}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetNewArticle.parse_obj(data)

    async def get_drafted_article(
        self, url_slug: str, language: Union[Optional[str], UnsetType] = UNSET
    ) -> GetDraftedArticle:
        query = gql(
            """
            query GetDraftedArticle($urlSlug: String!, $language: String) {
              getDraftedArticle(urlSlug: $urlSlug, language: $language) {
                id
                title
                body
                contentId
                standFirst
                standfirst
                backgroundColour
                seoDescription
                sEOTitle
                seoTitle
                urlSlug
                slug
                campaignId
                relatedUrls
                liveFrom
                articleType
                featureImageId
                featureImageEdited
                hideOnTheMainSite
                imageEdited
                mediaIds
                relatedMedia {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                eventId
                event {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                blogUpdated
                liveBlog
                language
                relatedCompetitorIds
                relatedCompetitors {
                  id
                  iaafId
                  firstName
                  lastName
                  friendlyName
                  fullName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthPlace
                  birthPlaceCountryName
                  sexNameUrlSlug
                  countryUrlSlug
                  birthPlaceCountryUrlSlug
                  birthCountryCode
                  primaryMediaId
                  primaryMediaEdited
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  transfersOfAllegiance
                  aaId
                  countryFullName
                  familyName
                  givenName
                  birthDateStr
                  facebookUsername
                  twitterUsername
                  instagramUsername
                  mediaIds
                }
                relatedDisciplineCodes
                relatedDiscipline {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                relatedCompetitionIds
                relatedCompetitions {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                relatedEventIds
                relatedEvents {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                relatedArticleIds
                relatedArticles {
                  id
                  title
                  body
                  contentId
                  standFirst
                  standfirst
                  backgroundColour
                  seoDescription
                  sEOTitle
                  seoTitle
                  urlSlug
                  slug
                  campaignId
                  relatedUrls
                  liveFrom
                  articleType
                  featureImageId
                  featureImageEdited
                  hideOnTheMainSite
                  imageEdited
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  blogUpdated
                  liveBlog
                  language
                  relatedCompetitorIds
                  relatedCompetitors {
                    id
                    iaafId
                    firstName
                    lastName
                    friendlyName
                    fullName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDate
                    birthPlace
                    birthPlaceCountryName
                    sexNameUrlSlug
                    countryUrlSlug
                    birthPlaceCountryUrlSlug
                    birthCountryCode
                    primaryMediaId
                    primaryMediaEdited
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    urlSlug
                    representativeId
                    biography
                    twitterLink
                    instagramLink
                    facebookLink
                    transfersOfAllegiance
                    aaId
                    countryFullName
                    familyName
                    givenName
                    birthDateStr
                    facebookUsername
                    twitterUsername
                    instagramUsername
                    mediaIds
                  }
                  relatedDisciplineCodes
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  relatedCompetitionIds
                  relatedCompetitions {
                    id
                    name
                    circuitTypeCode
                    eventSubCategoryCode
                    description
                    circuitCode
                    urlSlug
                    order
                    category
                    about
                    primaryMediaId
                    relatedMediaIds
                    logoLightId
                    logoDarkId
                    styleOverrides
                    relatedInfo
                    nextEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    lastEvent {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    nextEventStartDate
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  relatedEventIds
                  relatedEvents {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  relatedArticleIds
                  relatedArticles {
                    id
                    title
                    body
                    contentId
                    standFirst
                    standfirst
                    backgroundColour
                    seoDescription
                    sEOTitle
                    seoTitle
                    urlSlug
                    slug
                    campaignId
                    relatedUrls
                    liveFrom
                    articleType
                    featureImageId
                    featureImageEdited
                    hideOnTheMainSite
                    imageEdited
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    blogUpdated
                    liveBlog
                    language
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedCompetitionIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedEventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    relatedMinisiteIds
                    relatedMinisitePages {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    relatedCountryCodes
                    relatedRegionCodes
                    tags
                    relatedLinks {
                      displayText
                      url
                    }
                    published
                    columns
                    publishedById
                    publishedByName
                    relatedArticlesBackgroundColor
                    contentModules {
                      moduleType
                      title
                      backgroundColor
                      layout
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                  }
                  relatedMinisiteIds
                  relatedMinisitePages {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  relatedCountryCodes
                  relatedRegionCodes
                  tags
                  relatedLinks {
                    displayText
                    url
                  }
                  published
                  columns
                  publishedById
                  publishedByName
                  relatedArticlesBackgroundColor
                  contentModules {
                    moduleType
                    title
                    backgroundColor
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    layout
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                }
                relatedMinisiteIds
                relatedMinisitePages {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
                relatedCountryCodes
                relatedRegionCodes
                tags
                relatedLinks {
                  displayText
                  url
                }
                published
                columns
                publishedById
                publishedByName
                relatedArticlesBackgroundColor
                contentModules {
                  moduleType
                  title
                  backgroundColor
                  locations {
                    locationId
                    location {
                      id
                      name
                      latitude
                      longitude
                    }
                    headline
                    description
                    link
                    imageId
                    imageEdited
                  }
                  layout
                  videoIds
                  videoPlaylistId
                  relatedVideos {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                  videoId
                  relatedVideo {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                }
                gatedContent
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug, "language": language}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetDraftedArticle.parse_obj(data)

    async def get_assets(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        language: Union[Optional[str], UnsetType] = UNSET,
        type_id: Union[Optional[str], UnsetType] = UNSET,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
        filters: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        is_published: Union[Optional[bool], UnsetType] = UNSET,
        specific_filter_date: Union[Optional[Any], UnsetType] = UNSET,
    ) -> GetAssets:
        query = gql(
            """
            query GetAssets($limit: Int, $offset: Int, $language: String, $typeId: String, $minisiteId: String, $filters: [String], $isPublished: Boolean, $specificFilterDate: AWSDateTime) {
              getAssets(
                limit: $limit
                offset: $offset
                language: $language
                typeId: $typeId
                minisiteId: $minisiteId
                filters: $filters
                isPublished: $isPublished
                specificFilterDate: $specificFilterDate
              ) {
                id
                slug
                typeId
                thumbnailFeatureImageId
                thumbnailFeatureImageEdited
                thumbnailFeatureImage {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                gatedContent
                downloadOnly
                tags
                publishedByName
                published
                language
                title
                seoDescription
                video
                documentId
                document {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                filters {
                  id
                  contentId
                  typeId
                  type {
                    id
                    contentId
                    published
                    publishedById
                    publishedByName
                    filters {
                      id
                      contentId
                      typeId
                      published
                      publishedById
                      publishedByName
                      language
                      title
                      slug
                    }
                    language
                    title
                    slug
                    typeId
                    siteId
                  }
                  published
                  publishedById
                  publishedByName
                  language
                  title
                  slug
                }
                campaignId
                campaign {
                  id
                  name
                  tag
                  type
                  description
                  thankYouMessage
                  alreadySignedMessage
                  closeDate
                  redirectUrl
                  tagUserFriendlyName
                  backgroundImageEdited
                  headerImageEdited
                  visibleOnPreferenceCenter
                  shortForm
                  topLevelBucketId
                }
                date
              }
            }
            """
        )
        variables: dict[str, object] = {
            "limit": limit,
            "offset": offset,
            "language": language,
            "typeId": type_id,
            "minisiteId": minisite_id,
            "filters": filters,
            "isPublished": is_published,
            "specificFilterDate": specific_filter_date,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAssets.parse_obj(data)

    async def get_asset(
        self,
        slug: str,
        language: Union[Optional[str], UnsetType] = UNSET,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetAsset:
        query = gql(
            """
            query GetAsset($slug: String!, $language: String, $minisiteId: String) {
              getAsset(slug: $slug, language: $language, minisiteId: $minisiteId) {
                id
                slug
                typeId
                thumbnailFeatureImageId
                thumbnailFeatureImageEdited
                thumbnailFeatureImage {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                gatedContent
                downloadOnly
                tags
                publishedByName
                published
                language
                title
                seoDescription
                video
                documentId
                document {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                filters {
                  id
                  contentId
                  typeId
                  type {
                    id
                    contentId
                    published
                    publishedById
                    publishedByName
                    filters {
                      id
                      contentId
                      typeId
                      published
                      publishedById
                      publishedByName
                      language
                      title
                      slug
                    }
                    language
                    title
                    slug
                    typeId
                    siteId
                  }
                  published
                  publishedById
                  publishedByName
                  language
                  title
                  slug
                }
                campaignId
                campaign {
                  id
                  name
                  tag
                  type
                  description
                  thankYouMessage
                  alreadySignedMessage
                  closeDate
                  redirectUrl
                  tagUserFriendlyName
                  backgroundImageEdited
                  headerImageEdited
                  visibleOnPreferenceCenter
                  shortForm
                  topLevelBucketId
                }
                date
              }
            }
            """
        )
        variables: dict[str, object] = {
            "slug": slug,
            "language": language,
            "minisiteId": minisite_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAsset.parse_obj(data)

    async def get_assets_total(
        self,
        language: Union[Optional[str], UnsetType] = UNSET,
        filters: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
        is_published: Union[Optional[bool], UnsetType] = UNSET,
        specific_filter_date: Union[Optional[Any], UnsetType] = UNSET,
    ) -> GetAssetsTotal:
        query = gql(
            """
            query GetAssetsTotal($language: String, $filters: [String], $minisiteId: String, $isPublished: Boolean, $specificFilterDate: AWSDateTime) {
              getAssetsTotal(
                language: $language
                filters: $filters
                minisiteId: $minisiteId
                isPublished: $isPublished
                specificFilterDate: $specificFilterDate
              ) {
                total
              }
            }
            """
        )
        variables: dict[str, object] = {
            "language": language,
            "filters": filters,
            "minisiteId": minisite_id,
            "isPublished": is_published,
            "specificFilterDate": specific_filter_date,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAssetsTotal.parse_obj(data)

    async def get_assets_dates(
        self,
        language: Union[Optional[str], UnsetType] = UNSET,
        filters: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
        is_published: Union[Optional[bool], UnsetType] = UNSET,
        specific_filter_date: Union[Optional[Any], UnsetType] = UNSET,
    ) -> GetAssetsDates:
        query = gql(
            """
            query GetAssetsDates($language: String, $filters: [String], $minisiteId: String, $isPublished: Boolean, $specificFilterDate: AWSDateTime) {
              getAssetsDates(
                language: $language
                filters: $filters
                minisiteId: $minisiteId
                isPublished: $isPublished
                specificFilterDate: $specificFilterDate
              ) {
                dates
              }
            }
            """
        )
        variables: dict[str, object] = {
            "language": language,
            "filters": filters,
            "minisiteId": minisite_id,
            "isPublished": is_published,
            "specificFilterDate": specific_filter_date,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAssetsDates.parse_obj(data)

    async def get_trending_athletes(self) -> GetTrendingAthletes:
        query = gql(
            """
            query GetTrendingAthletes {
              getTrendingAthletes {
                id
                athleteIds
                athletesList {
                  id
                  iaafId
                  firstName
                  lastName
                  friendlyName
                  fullName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthPlace
                  birthPlaceCountryName
                  sexNameUrlSlug
                  countryUrlSlug
                  birthPlaceCountryUrlSlug
                  birthCountryCode
                  primaryMediaId
                  primaryMediaEdited
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  transfersOfAllegiance
                  aaId
                  countryFullName
                  familyName
                  givenName
                  birthDateStr
                  facebookUsername
                  twitterUsername
                  instagramUsername
                  mediaIds
                }
                primaryMediaId
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTrendingAthletes.parse_obj(data)

    async def get_athlete(self, url_slug: str) -> GetAthlete:
        query = gql(
            """
            query GetAthlete($urlSlug: String!) {
              getAthlete(urlSlug: $urlSlug) {
                id
                iaafId
                firstName
                lastName
                friendlyName
                fullName
                friendlyNameLetter
                friendlyNameFirst3Letter
                sexCode
                sexName
                countryCode
                countryName
                birthDate
                birthPlace
                birthPlaceCountryName
                sexNameUrlSlug
                countryUrlSlug
                birthPlaceCountryUrlSlug
                birthCountryCode
                primaryMediaId
                primaryMediaEdited
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                urlSlug
                representativeId
                biography
                twitterLink
                instagramLink
                facebookLink
                transfersOfAllegiance
                aaId
                countryFullName
                familyName
                givenName
                birthDateStr
                facebookUsername
                twitterUsername
                instagramUsername
                mediaIds
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthlete.parse_obj(data)

    async def search_athletes(
        self,
        event_id: int,
        country_code: Union[Optional[str], UnsetType] = UNSET,
        discipline_code: Union[Optional[str], UnsetType] = UNSET,
        sex_code: Union[Optional[str], UnsetType] = UNSET,
        search_value: Union[Optional[str], UnsetType] = UNSET,
    ) -> SearchAthletes:
        query = gql(
            """
            query SearchAthletes($eventId: Int!, $countryCode: String, $disciplineCode: String, $sexCode: String, $searchValue: String) {
              searchAthletes(
                eventId: $eventId
                countryCode: $countryCode
                disciplineCode: $disciplineCode
                sexCode: $sexCode
                searchValue: $searchValue
              ) {
                id
                iaafId
                firstName
                lastName
                friendlyName
                fullName
                friendlyNameLetter
                friendlyNameFirst3Letter
                sexCode
                sexName
                countryCode
                countryName
                birthDate
                birthPlace
                birthPlaceCountryName
                sexNameUrlSlug
                countryUrlSlug
                birthPlaceCountryUrlSlug
                birthCountryCode
                primaryMediaId
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                urlSlug
                representativeId
                biography
                twitterLink
                instagramLink
                facebookLink
                transfersOfAllegiance
                aaId
                countryFullName
                familyName
                givenName
                birthDateStr
                facebookUsername
                twitterUsername
                instagramUsername
                disciplines {
                  id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                competitionEntries {
                  id
                  eventId
                  eventId_WA
                  updatedOn
                  hash
                  sexCode
                  countryCode
                  countryName
                  competitorId
                  discipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "countryCode": country_code,
            "disciplineCode": discipline_code,
            "sexCode": sex_code,
            "searchValue": search_value,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return SearchAthletes.parse_obj(data)

    async def get_athlete_representative_athlete_search(
        self,
        country_code: Union[Optional[str], UnsetType] = UNSET,
        athlete_name: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetAthleteRepresentativeAthleteSearch:
        query = gql(
            """
            query GetAthleteRepresentativeAthleteSearch($countryCode: String, $athleteName: String) {
              getAthleteRepresentativeAthleteSearch(
                countryCode: $countryCode
                athleteName: $athleteName
              ) {
                countries {
                  country
                  countryCode
                }
                athletes {
                  group
                  children {
                    athleteRepresentativeId
                    countryCode
                    firstName
                    birthdate
                    athleteId
                    lastName
                    country
                    gender
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "countryCode": country_code,
            "athleteName": athlete_name,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteRepresentativeAthleteSearch.parse_obj(data)

    async def get_athlete_profile_athlete_representative(
        self, athlete_id: Union[Optional[int], UnsetType] = UNSET
    ) -> GetAthleteProfileAthleteRepresentative:
        query = gql(
            """
            query GetAthleteProfileAthleteRepresentative($athleteId: Int) {
              getAthleteProfileAthleteRepresentative(athleteId: $athleteId) {
                athleteRepresentativeId
                countryCode
                telephone
                firstName
                website
                lastName
                mobile
                country
                email
              }
            }
            """
        )
        variables: dict[str, object] = {"athleteId": athlete_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteProfileAthleteRepresentative.parse_obj(data)

    async def get_athlete_representative_profile(
        self, athlete_representative_id: Union[Optional[int], UnsetType] = UNSET
    ) -> GetAthleteRepresentativeProfile:
        query = gql(
            """
            query GetAthleteRepresentativeProfile($athleteRepresentativeId: Int) {
              getAthleteRepresentativeProfile(
                athleteRepresentativeId: $athleteRepresentativeId
              ) {
                athleteRepresentativeId
                countryCode
                instagram
                telephone
                facebook
                twitter
                website
                youtube
                firstName
                mobile
                lastName
                toplist {
                  athletes {
                    athleteRepresentativeId
                    countryCode
                    firstName
                    birthdate
                    athleteId
                    lastName
                    country
                    gender
                  }
                  toplistDate
                }
                country
                email
              }
            }
            """
        )
        variables: dict[str, object] = {
            "athleteRepresentativeId": athlete_representative_id
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteRepresentativeProfile.parse_obj(data)

    async def get_athlete_representative_top_list(
        self, event_id: Union[Optional[int], UnsetType] = UNSET
    ) -> GetAthleteRepresentativeTopList:
        query = gql(
            """
            query GetAthleteRepresentativeTopList($eventId: Int) {
              getAthleteRepresentativeTopList(eventId: $eventId) {
                genders {
                  gender
                  genderCode
                  selectedGender
                }
                events {
                  event
                  eventId
                  genderCode
                  eventTypeId
                  selectedEvent
                }
                toplist {
                  event
                  toplistDate
                  athletes {
                    rank
                    result
                    country
                    lastName
                    athleteId
                    birthdate
                    firstName
                    resultDate
                    athleteName
                    countryCode
                    resultVenue
                    representativeName
                    representativeTypeId
                    representativeLastName
                    athleteRepresentativeId
                    representativeFirstName
                  }
                }
                eventTypes {
                  eventType
                  eventTypeId
                  selectedEventType
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteRepresentativeTopList.parse_obj(data)

    async def get_athlete_representative_directory(
        self,
    ) -> GetAthleteRepresentativeDirectory:
        query = gql(
            """
            query GetAthleteRepresentativeDirectory {
              getAthleteRepresentativeDirectory {
                athleteRepresentativeId
                countryCode
                firstName
                birthdate
                athleteId
                lastName
                country
                gender
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAthleteRepresentativeDirectory.parse_obj(data)

    async def get_banners(self) -> GetBanners:
        query = gql(
            """
            query GetBanners {
              getBanners {
                id
                title
                bannerItems {
                  id
                  url
                  primaryMediaId
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  order
                }
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetBanners.parse_obj(data)

    async def get_carousel(self, type: CarouselTypeEnum) -> GetCarousel:
        query = gql(
            """
            query GetCarousel($type: CarouselTypeEnum!) {
              getCarousel(type: $type) {
                id
                title
                carouselItems {
                  id
                  title
                  description
                  descriptionSecond
                  descriptionThird
                  titleSecond
                  titleThird
                  titleFourth
                  titleFifth
                  titleDirection
                  homeCarouselId
                  url
                  urlSecond
                  urlThird
                  urlFourth
                  urlFifth
                  primaryMediaId
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  order
                }
                media {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                primaryMediaIds
              }
            }
            """
        )
        variables: dict[str, object] = {"type": type}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCarousel.parse_obj(data)

    async def get_hero_athletes_carousel(
        self, ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET
    ) -> GetHeroAthletesCarousel:
        query = gql(
            """
            query GetHeroAthletesCarousel($ids: [Int]) {
              getHeroAthletesCarousel(ids: $ids) {
                id
                iaafId
                firstName
                lastName
                friendlyName
                fullName
                friendlyNameLetter
                friendlyNameFirst3Letter
                sexCode
                sexName
                countryCode
                countryName
                birthDate
                birthPlace
                birthPlaceCountryName
                sexNameUrlSlug
                countryUrlSlug
                birthPlaceCountryUrlSlug
                birthCountryCode
                mediaIds
                relatedMedia {
                  id
                  mediaType
                  title
                  copyright
                  fileName
                  relatedAthletes
                  relatedDisciplines
                  relatedCompetitions
                  relatedEvents
                  isDeleted
                  liveFrom
                }
                urlSlug
                representativeId
                biography
                twitterLink
                instagramLink
                facebookLink
                transfersOfAllegiance
                aaId
                countryFullName
                familyName
                givenName
                birthDateStr
                facebookUsername
                twitterUsername
                instagramUsername
              }
            }
            """
        )
        variables: dict[str, object] = {"ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetHeroAthletesCarousel.parse_obj(data)

    async def get_championship_highlights(
        self,
        competition_id: Union[Optional[str], UnsetType] = UNSET,
        day: Union[Optional[int], UnsetType] = UNSET,
        current_day: Union[Optional[int], UnsetType] = UNSET,
        current_time: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetChampionshipHighlights:
        query = gql(
            """
            query GetChampionshipHighlights($competitionId: String, $day: Int, $currentDay: Int, $currentTime: String) {
              getChampionshipHighlights(
                competitionId: $competitionId
                day: $day
                currentDay: $currentDay
                currentTime: $currentTime
              ) {
                days {
                  date
                  day
                }
                rounds {
                  championshipRecords {
                    defendingChampion
                    equal
                    mark
                    pending
                    competitor {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    year
                  }
                  environment
                  event
                  eventType
                  disciplineCode
                  headToHead {
                    competitor {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      primaryMediaId
                    }
                    opponents {
                      competitorWins
                      opponentWins
                    }
                  }
                  highlights {
                    competitors {
                      mark
                      place
                      name
                      country
                      worldLeadHolder
                      worldRecordLabel
                      personalBest
                      seasonsBest
                      worldRankingPosition
                    }
                    label
                  }
                  pastMedalists {
                    competitor {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    place
                    mark
                  }
                  round
                  sex
                  time
                  title
                  worldRecords {
                    competitor {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    equal
                    mark
                    pending
                    year
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "day": day,
            "currentDay": current_day,
            "currentTime": current_time,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetChampionshipHighlights.parse_obj(data)

    async def get_all_competitions(self) -> GetAllCompetitions:
        query = gql(
            """
            query GetAllCompetitions {
              getAllCompetitions {
                pageNextEvent {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
                allEvents {
                  id
                  name
                  circuitTypeCode
                  eventSubCategoryCode
                  description
                  circuitCode
                  urlSlug
                  order
                  category
                  about
                  primaryMediaId
                  relatedMediaIds
                  logoLightId
                  logoDarkId
                  styleOverrides
                  relatedInfo
                  nextEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  lastEvent {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  nextEventStartDate
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAllCompetitions.parse_obj(data)

    async def get_competition_organiser_info(
        self, competition_id: int
    ) -> GetCompetitionOrganiserInfo:
        query = gql(
            """
            query GetCompetitionOrganiserInfo($competitionId: Int!) {
              getCompetitionOrganiserInfo(competitionId: $competitionId) {
                units {
                  events
                  gender
                }
                websiteUrl
                resultsPageUrl
                liveStreamingUrl
                contactPersonsGeneralMatters {
                  name
                  email
                  phoneNumber
                }
                contactPersonsGeneralResults {
                  name
                  email
                  phoneNumber
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"competitionId": competition_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCompetitionOrganiserInfo.parse_obj(data)

    async def get_waw_competition(self, url_slug: str) -> GetWawCompetition:
        query = gql(
            """
            query GetWawCompetition($urlSlug: String!) {
              getWawCompetition(urlSlug: $urlSlug) {
                id
                name
                circuitTypeCode
                eventSubCategoryCode
                description
                circuitCode
                urlSlug
                order
                category
                about
                primaryMediaId
                relatedMediaIds
                logoLightId
                logoDarkId
                styleOverrides
                relatedInfo
                nextEvent {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                lastEvent {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                nextEventStartDate
                pageId
                page {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawCompetition.parse_obj(data)

    async def get_waw_competition_events_organizer_details(
        self, url_slug: str
    ) -> GetWawCompetitionEventsOrganizerDetails:
        query = gql(
            """
            query GetWawCompetitionEventsOrganizerDetails($urlSlug: String!) {
              getWawCompetitionEventsOrganizerDetails(urlSlug: $urlSlug) {
                id
                eventId_WA
                name
                startDate
                venue
                countryCode
                organizerDetails {
                  name
                  value
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawCompetitionEventsOrganizerDetails.parse_obj(data)

    async def get_single_competitor(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        url_slug: Union[Optional[str], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> GetSingleCompetitor:
        query = gql(
            """
            query GetSingleCompetitor($id: Int, $urlSlug: String, $ids: [Int]) {
              getSingleCompetitor(id: $id, urlSlug: $urlSlug, ids: $ids) {
                _id
                basicData {
                  id
                  iaafId
                  firstName
                  lastName
                  friendlyName
                  fullName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthPlace
                  birthPlaceCountryName
                  sexNameUrlSlug
                  countryUrlSlug
                  birthPlaceCountryUrlSlug
                  birthCountryCode
                  primaryMediaId
                  primaryMediaEdited
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                  urlSlug
                  representativeId
                  biography
                  twitterLink
                  instagramLink
                  facebookLink
                  transfersOfAllegiance
                  aaId
                  countryFullName
                  familyName
                  givenName
                  birthDateStr
                  facebookUsername
                  twitterUsername
                  instagramUsername
                  mediaIds
                }
                personalBests {
                  withWind
                  withRecords
                  results {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    linkToList
                    mark
                    combinedPerformances
                    wind
                    notLegal
                    venue
                    date
                    listPosition
                    resultScore
                    records
                  }
                }
                seasonsBests {
                  parameters {
                    seasonsBestsSeason
                  }
                  activeSeasons
                  withWind
                  withRecords
                  results {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    linkToList
                    mark
                    combinedPerformances
                    wind
                    notLegal
                    venue
                    date
                    listPosition
                    resultScore
                    records
                  }
                }
                progressionOfSeasonsBests {
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  withWind
                  mainEvent
                  results {
                    season
                    numericResult
                    mark
                    wind
                    venue
                    date
                    listPosition
                    resultScore
                  }
                }
                worldRankings {
                  parameters {
                    worldRankingsProgressionYear
                  }
                  current {
                    rankingCalculationId
                    eventGroup
                    male
                    urlSlug
                    place
                    rankingScore
                  }
                  best {
                    eventGroup
                    eventGroupId
                    urlSlug
                    place
                    weeks
                  }
                }
                honours {
                  categoryName
                  withWind
                  withDrop
                  results {
                    place
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    competition
                    venue
                    mark
                    date
                  }
                }
                resultsByYear {
                  parameters {
                    resultsByYear
                    resultsByYearOrderBy
                  }
                  activeYears
                  resultsByEvent {
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    withWind
                    results {
                      date
                      competition
                      venue
                      country
                      category
                      race
                      place
                      mark
                      wind
                      notLegal
                      resultScore
                      remark
                    }
                  }
                }
                resultsByDate {
                  parameters {
                    resultsByYear
                    resultsByYearOrderBy
                  }
                  activeYears
                  resultsByDate {
                    date
                    competition
                    venue
                    indoor
                    disciplineCode
                    disciplineNameUrlSlug
                    typeNameUrlSlug
                    discipline
                    country
                    category
                    race
                    place
                    mark
                    wind
                    notLegal
                    resultScore
                    remark
                  }
                }
                primaryMediaId
                primaryMediaId2
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                athleteRepresentative {
                  _id
                  name
                  countryCode
                  countryName
                  email
                  telephone
                  mobile
                  website
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id, "urlSlug": url_slug, "ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitor.parse_obj(data)

    async def get_single_competitor_results_discipline(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        results_by_year: Union[Optional[int], UnsetType] = UNSET,
        results_by_year_order_by: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetSingleCompetitorResultsDiscipline:
        query = gql(
            """
            query GetSingleCompetitorResultsDiscipline($id: Int, $resultsByYear: Int, $resultsByYearOrderBy: String) {
              getSingleCompetitorResultsDiscipline(
                id: $id
                resultsByYear: $resultsByYear
                resultsByYearOrderBy: $resultsByYearOrderBy
              ) {
                parameters {
                  resultsByYear
                  resultsByYearOrderBy
                }
                activeYears
                resultsByEvent {
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  withWind
                  results {
                    date
                    competition
                    venue
                    indoor
                    country
                    category
                    race
                    place
                    mark
                    wind
                    notLegal
                    resultScore
                    remark
                  }
                }
                resultsByDate {
                  date
                  competition
                  venue
                  indoor
                  country
                  category
                  race
                  place
                  mark
                  wind
                  notLegal
                  resultScore
                  remark
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "resultsByYear": results_by_year,
            "resultsByYearOrderBy": results_by_year_order_by,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorResultsDiscipline.parse_obj(data)

    async def get_single_competitor_results_date(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        results_by_year: Union[Optional[int], UnsetType] = UNSET,
        results_by_year_order_by: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetSingleCompetitorResultsDate:
        query = gql(
            """
            query GetSingleCompetitorResultsDate($id: Int, $resultsByYear: Int, $resultsByYearOrderBy: String) {
              getSingleCompetitorResultsDate(
                id: $id
                resultsByYear: $resultsByYear
                resultsByYearOrderBy: $resultsByYearOrderBy
              ) {
                parameters {
                  resultsByYear
                  resultsByYearOrderBy
                }
                activeYears
                resultsByDate {
                  date
                  competition
                  venue
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  country
                  category
                  race
                  place
                  mark
                  wind
                  notLegal
                  resultScore
                  remark
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "resultsByYear": results_by_year,
            "resultsByYearOrderBy": results_by_year_order_by,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorResultsDate.parse_obj(data)

    async def get_single_competitor_major_championships(
        self,
        url_slug: str,
        id: Union[Optional[int], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> GetSingleCompetitorMajorChampionships:
        query = gql(
            """
            query GetSingleCompetitorMajorChampionships($id: Int, $urlSlug: String!, $ids: [Int]) {
              getSingleCompetitorMajorChampionships(id: $id, urlSlug: $urlSlug, ids: $ids) {
                parameters {
                  majorChampionshipsByCategory
                }
                results {
                  category
                  results {
                    id
                    discipline
                    competition
                    venue
                    race
                    place
                    result
                    withWind
                    wind
                    withDrop
                    drop
                    date
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id, "urlSlug": url_slug, "ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorMajorChampionships.parse_obj(data)

    async def get_single_competitor_all_time_personal_top10(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        url_slug: Union[Optional[str], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        all_time_personal_top10_discipline: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetSingleCompetitorAllTimePersonalTop10:
        query = gql(
            """
            query GetSingleCompetitorAllTimePersonalTop10($id: Int, $urlSlug: String, $ids: [Int], $allTimePersonalTop10Discipline: Int) {
              getSingleCompetitorAllTimePersonalTop10(
                id: $id
                urlSlug: $urlSlug
                ids: $ids
                allTimePersonalTop10Discipline: $allTimePersonalTop10Discipline
              ) {
                parameters {
                  allTimePersonalTop10Discipline
                }
                disciplines {
                  id
                  name
                }
                results {
                  discipline
                  date
                  competition
                  country
                  category
                  race
                  place
                  result
                  wind
                  drop
                  withWind
                  withDrop
                  score
                  records
                  remark
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "urlSlug": url_slug,
            "ids": ids,
            "allTimePersonalTop10Discipline": all_time_personal_top10_discipline,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorAllTimePersonalTop10.parse_obj(data)

    async def get_single_competitor_honour_summary(
        self,
        url_slug: str,
        id: Union[Optional[int], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> GetSingleCompetitorHonourSummary:
        query = gql(
            """
            query GetSingleCompetitorHonourSummary($id: Int, $urlSlug: String!, $ids: [Int]) {
              getSingleCompetitorHonourSummary(id: $id, urlSlug: $urlSlug, ids: $ids) {
                count
                honour
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id, "urlSlug": url_slug, "ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorHonourSummary.parse_obj(data)

    async def get_single_competitor_results_by_limit(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        url_slug: Union[Optional[str], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        results_by_limits_discipline: Union[Optional[str], UnsetType] = UNSET,
        results_by_limits_start_date: Union[Optional[str], UnsetType] = UNSET,
        results_by_limits_end_date: Union[Optional[str], UnsetType] = UNSET,
        results_by_limits_only_regular: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetSingleCompetitorResultsByLimit:
        query = gql(
            """
            query GetSingleCompetitorResultsByLimit($id: Int, $urlSlug: String, $ids: [Int], $resultsByLimitsDiscipline: String, $resultsByLimitsStartDate: String, $resultsByLimitsEndDate: String, $resultsByLimitsOnlyRegular: Boolean) {
              getSingleCompetitorResultsByLimit(
                id: $id
                urlSlug: $urlSlug
                ids: $ids
                resultsByLimitsDiscipline: $resultsByLimitsDiscipline
                resultsByLimitsStartDate: $resultsByLimitsStartDate
                resultsByLimitsEndDate: $resultsByLimitsEndDate
                resultsByLimitsOnlyRegular: $resultsByLimitsOnlyRegular
              ) {
                parameters {
                  resultsByLimitsDiscipline
                  resultsByLimitsStartDate
                  resultsByLimitsEndDate
                  resultsByLimitsOnlyRegular
                }
                disciplines {
                  id
                  name
                }
                results {
                  result
                  count
                  totalCount
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "urlSlug": url_slug,
            "ids": ids,
            "resultsByLimitsDiscipline": results_by_limits_discipline,
            "resultsByLimitsStartDate": results_by_limits_start_date,
            "resultsByLimitsEndDate": results_by_limits_end_date,
            "resultsByLimitsOnlyRegular": results_by_limits_only_regular,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorResultsByLimit.parse_obj(data)

    async def get_single_competitor_winning_streak(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        url_slug: Union[Optional[str], UnsetType] = UNSET,
        ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        winning_streaks_discipline_option: Union[Optional[str], UnsetType] = UNSET,
        winning_streaks_start_date: Union[Optional[str], UnsetType] = UNSET,
        winning_streaks_end_date: Union[Optional[str], UnsetType] = UNSET,
        winning_streaks_final_only: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetSingleCompetitorWinningStreak:
        query = gql(
            """
            query GetSingleCompetitorWinningStreak($id: Int, $urlSlug: String, $ids: [Int], $winningStreaksDisciplineOption: String, $winningStreaksStartDate: String, $winningStreaksEndDate: String, $winningStreaksFinalOnly: Boolean) {
              getSingleCompetitorWinningStreak(
                id: $id
                urlSlug: $urlSlug
                ids: $ids
                winningStreaksDisciplineOption: $winningStreaksDisciplineOption
                winningStreaksStartDate: $winningStreaksStartDate
                winningStreaksEndDate: $winningStreaksEndDate
                winningStreaksFinalOnly: $winningStreaksFinalOnly
              ) {
                parameters {
                  winningStreaksDisciplineOption
                  winningStreaksStartDate
                  winningStreaksEndDate
                  winningStreaksFinalOnly
                }
                disciplineOptions {
                  id
                  name
                }
                streaks {
                  length
                  results {
                    date
                    venue
                    competition
                    race
                    result
                    discipline
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "urlSlug": url_slug,
            "ids": ids,
            "winningStreaksDisciplineOption": winning_streaks_discipline_option,
            "winningStreaksStartDate": winning_streaks_start_date,
            "winningStreaksEndDate": winning_streaks_end_date,
            "winningStreaksFinalOnly": winning_streaks_final_only,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorWinningStreak.parse_obj(data)

    async def head_to_head(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        head_to_head_discipline: Union[Optional[str], UnsetType] = UNSET,
        head_to_head_opponent: Union[Optional[int], UnsetType] = UNSET,
        head_to_head_start_date: Union[Optional[str], UnsetType] = UNSET,
        head_to_head_end_date: Union[Optional[str], UnsetType] = UNSET,
        head_to_head_final_only: Union[Optional[bool], UnsetType] = UNSET,
    ) -> HeadToHead:
        query = gql(
            """
            query HeadToHead($id: Int, $headToHeadDiscipline: String, $headToHeadOpponent: Int, $headToHeadStartDate: String, $headToHeadEndDate: String, $headToHeadFinalOnly: Boolean) {
              headToHead(
                id: $id
                headToHeadDiscipline: $headToHeadDiscipline
                headToHeadOpponent: $headToHeadOpponent
                headToHeadStartDate: $headToHeadStartDate
                headToHeadEndDate: $headToHeadEndDate
                headToHeadFinalOnly: $headToHeadFinalOnly
              ) {
                disciplines {
                  id
                  name
                }
                opponents {
                  birthDate
                  country
                  familyName
                  gender
                  givenName
                  id
                }
                parameters {
                  headToHeadDiscipline
                  headToHeadEndDate
                  headToHeadFinalOnly
                  headToHeadOpponent
                  headToHeadStartDate
                }
                results {
                  athlete1Wins
                  athlete2Wins
                  results {
                    athlete1Wins
                    athlete2Wins
                    competition
                    date
                    discipline
                    place1
                    place2
                    race
                    raceType
                    result1
                    result2
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "headToHeadDiscipline": head_to_head_discipline,
            "headToHeadOpponent": head_to_head_opponent,
            "headToHeadStartDate": head_to_head_start_date,
            "headToHeadEndDate": head_to_head_end_date,
            "headToHeadFinalOnly": head_to_head_final_only,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return HeadToHead.parse_obj(data)

    async def get_single_competitor_season_bests(
        self,
        id: Union[Optional[int], UnsetType] = UNSET,
        seasons_bests_season: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetSingleCompetitorSeasonBests:
        query = gql(
            """
            query GetSingleCompetitorSeasonBests($id: Int, $seasonsBestsSeason: Int) {
              getSingleCompetitorSeasonBests(id: $id, seasonsBestsSeason: $seasonsBestsSeason) {
                parameters {
                  seasonsBestsSeason
                }
                activeSeasons
                withWind
                withRecords
                results {
                  indoor
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  discipline
                  linkToList
                  mark
                  combinedPerformances
                  wind
                  notLegal
                  venue
                  date
                  listPosition
                  resultScore
                  records
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "id": id,
            "seasonsBestsSeason": seasons_bests_season,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSingleCompetitorSeasonBests.parse_obj(data)

    async def get_competitor_a_a_id(
        self, iaaf_id: Union[Optional[int], UnsetType] = UNSET
    ) -> GetCompetitorAAId:
        query = gql(
            """
            query GetCompetitorAAId($iaafId: Int) {
              getCompetitorAAId(iaafId: $iaafId)
            }
            """
        )
        variables: dict[str, object] = {"iaafId": iaaf_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCompetitorAAId.parse_obj(data)

    async def countries_by_event_id(
        self, event_id: Union[Optional[int], UnsetType] = UNSET
    ) -> CountriesByEventId:
        query = gql(
            """
            query CountriesByEventId($eventId: Int) {
              countriesByEventId(eventId: $eventId) {
                updatedOn
                hash
                id
                countryName
                countryOrder
                areaCode
                areaName
                areaOrder
                isValid
                areaNameUrlSlug
                countryNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return CountriesByEventId.parse_obj(data)

    async def get_countries(self) -> GetCountries:
        query = gql(
            """
            query GetCountries {
              getCountries {
                updatedOn
                hash
                id
                countryName
                countryOrder
                areaCode
                areaName
                areaOrder
                isValid
                areaNameUrlSlug
                countryNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCountries.parse_obj(data)

    async def get_discipline(self, url_slug: str) -> GetDiscipline:
        query = gql(
            """
            query GetDiscipline($urlSlug: String!) {
              getDiscipline(urlSlug: $urlSlug) {
                id
                updatedOn
                hash
                name
                typeCode
                typeName
                typeOrder
                order
                isTrack
                isField
                isRoad
                isCombined
                isWalk
                isIndoor
                isReaction
                isOutdoor
                isWind
                isRelay
                isValidIAAF
                nameUrlSlug
                typeNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"urlSlug": url_slug}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetDiscipline.parse_obj(data)

    async def disciplines_by_event_id(self, event_id: int) -> DisciplinesByEventId:
        query = gql(
            """
            query DisciplinesByEventId($eventId: Int!) {
              disciplinesByEventId(eventId: $eventId) {
                id
                updatedOn
                hash
                name
                typeCode
                typeName
                typeOrder
                order
                isTrack
                isField
                isRoad
                isCombined
                isWalk
                isIndoor
                isReaction
                isOutdoor
                isWind
                isRelay
                isValidIAAF
                nameUrlSlug
                typeNameUrlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {"eventId": event_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return DisciplinesByEventId.parse_obj(data)

    async def get_calendar_events(
        self,
        start_date: Union[Optional[str], UnsetType] = UNSET,
        end_date: Union[Optional[str], UnsetType] = UNSET,
        query: Union[Optional[str], UnsetType] = UNSET,
        region_type: Union[Optional[str], UnsetType] = UNSET,
        region_id: Union[Optional[int], UnsetType] = UNSET,
        discipline_id: Union[Optional[int], UnsetType] = UNSET,
        ranking_category_id: Union[Optional[int], UnsetType] = UNSET,
        permit_level_id: Union[Optional[int], UnsetType] = UNSET,
        current_season: Union[Optional[bool], UnsetType] = UNSET,
        competition_group_id: Union[Optional[int], UnsetType] = UNSET,
        competition_group_slug: Union[Optional[str], UnsetType] = UNSET,
        competition_subgroup_id: Union[Optional[int], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        show_options_with_no_hits: Union[Optional[bool], UnsetType] = UNSET,
        hide_competitions_with_no_results: Union[Optional[bool], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetCalendarEvents:
        query = gql(
            """
            query GetCalendarEvents($startDate: String, $endDate: String, $query: String, $regionType: String, $regionId: Int, $disciplineId: Int, $rankingCategoryId: Int, $permitLevelId: Int, $currentSeason: Boolean, $competitionGroupId: Int, $competitionGroupSlug: String, $competitionSubgroupId: Int, $limit: Int, $offset: Int, $showOptionsWithNoHits: Boolean, $hideCompetitionsWithNoResults: Boolean, $orderDirection: OrderDirectionEnum) {
              getCalendarEvents(
                startDate: $startDate
                endDate: $endDate
                query: $query
                regionType: $regionType
                regionId: $regionId
                disciplineId: $disciplineId
                rankingCategoryId: $rankingCategoryId
                permitLevelId: $permitLevelId
                currentSeason: $currentSeason
                competitionGroupId: $competitionGroupId
                competitionGroupSlug: $competitionGroupSlug
                competitionSubgroupId: $competitionSubgroupId
                limit: $limit
                offset: $offset
                showOptionsWithNoHits: $showOptionsWithNoHits
                hideCompetitionsWithNoResults: $hideCompetitionsWithNoResults
                orderDirection: $orderDirection
              ) {
                hits
                defaultOffset
                paginationPage
                parameters {
                  startDate
                  endDate
                  query
                  regionType
                  regionId
                  disciplineId
                  rankingCategoryId
                  permitLevelId
                  competitionGroupId
                  competitionSubgroupId
                  limit
                  offset
                  showOptionsWithNoHits
                  hideCompetitionsWithNoResults
                  season
                }
                results {
                  id
                  iaafId
                  hasResults
                  hasApiResults
                  hasStartlist
                  name
                  venue
                  area
                  country
                  rankingCategory
                  disciplines
                  competitionGroup
                  competitionSubgroup
                  startDate
                  endDate
                  dateRange
                  season
                  wasUrl
                  hasCompetitionInformation
                  undeterminedCompetitionPeriod {
                    status
                    label
                    remark
                  }
                }
                options {
                  regions {
                    world {
                      id
                      name
                      count
                    }
                    area {
                      id
                      name
                      count
                    }
                    country {
                      id
                      name
                      count
                    }
                  }
                  seasons {
                    id
                    name
                  }
                  disciplines {
                    id
                    name
                    count
                  }
                  rankingCategories {
                    id
                    name
                    count
                  }
                  permitLevels {
                    id
                    name
                    count
                  }
                  competitionGroups {
                    id
                    name
                    count
                  }
                  competitionSubgroups {
                    id
                    name
                    count
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "startDate": start_date,
            "endDate": end_date,
            "query": query,
            "regionType": region_type,
            "regionId": region_id,
            "disciplineId": discipline_id,
            "rankingCategoryId": ranking_category_id,
            "permitLevelId": permit_level_id,
            "currentSeason": current_season,
            "competitionGroupId": competition_group_id,
            "competitionGroupSlug": competition_group_slug,
            "competitionSubgroupId": competition_subgroup_id,
            "limit": limit,
            "offset": offset,
            "showOptionsWithNoHits": show_options_with_no_hits,
            "hideCompetitionsWithNoResults": hide_competitions_with_no_results,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCalendarEvents.parse_obj(data)

    async def get_calendar_competition_results(
        self,
        competition_id: Union[Optional[int], UnsetType] = UNSET,
        day: Union[Optional[int], UnsetType] = UNSET,
        event_id: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetCalendarCompetitionResults:
        query = gql(
            """
            query GetCalendarCompetitionResults($competitionId: Int, $day: Int, $eventId: Int) {
              getCalendarCompetitionResults(
                competitionId: $competitionId
                day: $day
                eventId: $eventId
              ) {
                competition {
                  dateRange
                  endDate
                  name
                  rankingCategory
                  startDate
                  venue
                }
                eventTitles {
                  eventTitle
                  events {
                    event
                    eventId
                    gender
                    isRelay
                    perResultWind
                    races {
                      date
                      day
                      race
                      raceId
                      raceNumber
                      wind
                    }
                    summary {
                      mark
                      nationality
                      placeInRace
                      placeInRound
                      points
                      raceNumber
                      records
                      wind
                    }
                    withWind
                  }
                  rankingCategory
                }
                options {
                  days {
                    date
                    day
                  }
                  events {
                    gender
                    id
                    name
                    combined
                  }
                }
                parameters {
                  competitionId
                  day
                  eventId
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "day": day,
            "eventId": event_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCalendarCompetitionResults.parse_obj(data)

    async def get_minisite_calendar_events(
        self,
        season: Union[Optional[str], UnsetType] = UNSET,
        competition_group_id: Union[Optional[int], UnsetType] = UNSET,
        competition_subgroup_id: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetMinisiteCalendarEvents:
        query = gql(
            """
            query GetMinisiteCalendarEvents($season: String, $competitionGroupId: Int, $competitionSubgroupId: Int) {
              getMinisiteCalendarEvents(
                season: $season
                competitionGroupId: $competitionGroupId
                competitionSubgroupId: $competitionSubgroupId
              ) {
                hits
                defaultOffset
                paginationPage
                parameters {
                  startDate
                  endDate
                  query
                  regionType
                  regionId
                  disciplineId
                  rankingCategoryId
                  permitLevelId
                  competitionGroupId
                  competitionSubgroupId
                  limit
                  offset
                  showOptionsWithNoHits
                  hideCompetitionsWithNoResults
                  season
                }
                results {
                  id
                  iaafId
                  hasResults
                  hasApiResults
                  hasStartlist
                  name
                  venue
                  area
                  country
                  rankingCategory
                  disciplines
                  competitionGroup
                  competitionSubgroup
                  startDate
                  endDate
                  dateRange
                  season
                  wasUrl
                  hasCompetitionInformation
                  undeterminedCompetitionPeriod {
                    status
                    label
                    remark
                  }
                }
                options {
                  regions {
                    world {
                      id
                      name
                      count
                    }
                    area {
                      id
                      name
                      count
                    }
                    country {
                      id
                      name
                      count
                    }
                  }
                  seasons {
                    id
                    name
                  }
                  disciplines {
                    id
                    name
                    count
                  }
                  rankingCategories {
                    id
                    name
                    count
                  }
                  permitLevels {
                    id
                    name
                    count
                  }
                  competitionGroups {
                    id
                    name
                    count
                  }
                  competitionSubgroups {
                    id
                    name
                    count
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "season": season,
            "competitionGroupId": competition_group_id,
            "competitionSubgroupId": competition_subgroup_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMinisiteCalendarEvents.parse_obj(data)

    async def get_event_circuit_standings(
        self,
        event_circuit_type_code: Union[Optional[str], UnsetType] = UNSET,
        season: Union[Optional[int], UnsetType] = UNSET,
        sex_code: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetEventCircuitStandings:
        query = gql(
            """
            query GetEventCircuitStandings($eventCircuitTypeCode: String, $season: Int, $sexCode: String) {
              getEventCircuitStandings(
                eventCircuitTypeCode: $eventCircuitTypeCode
                season: $season
                sexCode: $sexCode
              ) {
                circuitName
                parameters {
                  gender
                  season
                }
                seasons
                standings {
                  disciplines
                  entries {
                    athleteId
                    athlete
                    country
                    rank
                    points
                    results {
                      discipline
                      points
                      result
                      venue
                      place
                      date
                      details
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventCircuitTypeCode": event_circuit_type_code,
            "season": season,
            "sexCode": sex_code,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventCircuitStandings.parse_obj(data)

    async def get_event_leading_standings(
        self, event_circuit_type_code: Union[Optional[str], UnsetType] = UNSET
    ) -> GetEventLeadingStandings:
        query = gql(
            """
            query GetEventLeadingStandings($eventCircuitTypeCode: String) {
              getEventLeadingStandings(eventCircuitTypeCode: $eventCircuitTypeCode) {
                eventCircuitCode
                sexCode
                season
                eventCircuitTypeCode
                rank
                competitorId
                competitorId_WA
                competitorName
                competitorCountryCode
                totalResults
                totalPoints
                eventCircuitStandingOrder
                discipline {
                  name
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"eventCircuitTypeCode": event_circuit_type_code}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventLeadingStandings.parse_obj(data)

    async def get_event_phases(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[eventPhaseOrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetEventPhases:
        query = gql(
            """
            query GetEventPhases($eventId: Int, $orderBy: eventPhaseOrderByEnum, $orderDirection: OrderDirectionEnum) {
              getEventPhases(
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                unitName
                unitTypeName
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventPhases.parse_obj(data)

    async def get_event_phase_by_discipline(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        discipline_code: Union[Optional[str], UnsetType] = UNSET,
        sex_code: Union[Optional[str], UnsetType] = UNSET,
        phase_code: Union[Optional[str], UnsetType] = UNSET,
        combined_event: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetEventPhaseByDiscipline:
        query = gql(
            """
            query GetEventPhaseByDiscipline($eventId: Int, $disciplineCode: String, $sexCode: String, $phaseCode: String, $combinedEvent: String) {
              getEventPhaseByDiscipline(
                eventId: $eventId
                disciplineCode: $disciplineCode
                sexCode: $sexCode
                phaseCode: $phaseCode
                combinedEvent: $combinedEvent
              ) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                isTrack
                units {
                  unitId
                  unitDateTime
                  hasStandingPoints
                  unitRuleDetail
                  unitTypeCode
                  unitTypeName
                  unitCode
                  unitOrder
                  results {
                    competitorName
                    competitorFirstName
                    competitorLastName
                    competitorId_WA
                    teamId_WA
                    competitorTypeCode
                    resultCountryName
                    resultCountryCode
                    competitorCountryName
                    competitorCountryCode
                    standingPoints
                    combinedPoints
                    competitorId
                    resultMark
                    resultWind
                    resultRank
                    resultOrder
                    reactionTime
                    record
                    bib
                    qualified
                    teamMembers {
                      competitorId
                      competitorId_WA
                      competitorName
                      competitorFirstName
                      competitorLastName
                      competitorCountryCode
                      resultMark
                      resultRank
                      resultCountryName
                      resultCountryCode
                      countryName
                      competitorOrder
                      standingDetailScoring
                    }
                  }
                  startlist {
                    competitorName
                    competitorFirstName
                    competitorLastName
                    competitorId_WA
                    teamId_WA
                    competitorTypeCode
                    competitorCountryName
                    competitorCountryCode
                    resultCountryName
                    resultCountryCode
                    competitorId
                    personalBestMark
                    seasonBestMark
                    worldRanking
                    bib
                    startlistOrder
                    record
                    start
                    teamMembers {
                      competitorId
                      competitorId_WA
                      competitorName
                      competitorFirstName
                      competitorLastName
                      competitorCountryCode
                      resultMark
                      resultRank
                      resultCountryName
                      resultCountryCode
                      countryName
                      competitorOrder
                      standingDetailScoring
                    }
                  }
                  series {
                    competitorName
                    competitorFirstName
                    competitorLastName
                    competitorId_WA
                    teamId_WA
                    competitorTypeCode
                    resultCountryName
                    resultCountryCode
                    competitorCountryName
                    competitorCountryCode
                    competitorId
                    bib
                    startlistOrder
                    qualified
                    resultWind
                    resultMark
                    resultOrder
                    record
                    attempts {
                      intermediateMark
                      intermediateWind
                      competitionIntermediateName
                      intermediateGap
                    }
                  }
                  splits {
                    competitionIntermediateResultOrder
                    competitionIntermediateName
                    intermediateMark
                    intermediateGap
                    competitorName
                    competitorFirstName
                    competitorLastName
                    competitorCountryCode
                    competitorCountryName
                    resultCountryName
                    resultCountryCode
                    competitorId_WA
                  }
                  teamStandings {
                    _id
                    phaseId
                    unitId
                    rank
                    teamId
                    teamName
                    teamCountryCode
                    standingMark
                    competitorId
                    teamStandingOrder
                    teamEventPoints
                    teamId_WA
                    competitorId_WA
                    teamMembers {
                      competitorId
                      competitorId_WA
                      competitorName
                      competitorFirstName
                      competitorLastName
                      competitorCountryCode
                      resultMark
                      resultRank
                      resultCountryName
                      resultCountryCode
                      countryName
                      competitorOrder
                      standingDetailScoring
                    }
                  }
                }
                summary {
                  competitorName
                  competitorFirstName
                  competitorLastName
                  competitorId_WA
                  teamId_WA
                  competitorTypeCode
                  competitorCountryName
                  competitorCountryCode
                  resultCountryName
                  resultCountryCode
                  phaseSummaryOrder
                  combinedPoints
                  competitorId
                  resultMark
                  resultWind
                  resultRank
                  resultOrder
                  unitCode
                  unitName
                  reactionTime
                  record
                  bib
                  qualified
                  summaryRank
                  teamMembers {
                    competitorId
                    competitorId_WA
                    competitorName
                    competitorFirstName
                    competitorLastName
                    competitorCountryCode
                    resultMark
                    resultRank
                    resultCountryName
                    resultCountryCode
                    countryName
                    competitorOrder
                    standingDetailScoring
                  }
                }
                documents {
                  type
                  typeName
                  fileName
                  filePath
                  unitId
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "disciplineCode": discipline_code,
            "sexCode": sex_code,
            "phaseCode": phase_code,
            "combinedEvent": combined_event,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventPhaseByDiscipline.parse_obj(data)

    async def get_all_event_phases_by_discipline(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        discipline_code: Union[Optional[str], UnsetType] = UNSET,
        sex_code: Union[Optional[str], UnsetType] = UNSET,
        combined_event: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetAllEventPhasesByDiscipline:
        query = gql(
            """
            query GetAllEventPhasesByDiscipline($eventId: Int, $disciplineCode: String, $sexCode: String, $combinedEvent: String) {
              getAllEventPhasesByDiscipline(
                eventId: $eventId
                disciplineCode: $disciplineCode
                sexCode: $sexCode
                combinedEvent: $combinedEvent
              ) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                unitName
                unitTypeName
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "disciplineCode": discipline_code,
            "sexCode": sex_code,
            "combinedEvent": combined_event,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAllEventPhasesByDiscipline.parse_obj(data)

    async def get_combined_points(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        sex_code: Union[Optional[str], UnsetType] = UNSET,
        combined_discipline_type: Union[Optional[str], UnsetType] = UNSET,
        current_combined_discipline: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetCombinedPoints:
        query = gql(
            """
            query GetCombinedPoints($eventId: Int, $sexCode: String, $combinedDisciplineType: String, $currentCombinedDiscipline: String) {
              getCombinedPoints(
                eventId: $eventId
                sexCode: $sexCode
                combinedDisciplineType: $combinedDisciplineType
                currentCombinedDiscipline: $currentCombinedDiscipline
              ) {
                allDisciplines {
                  disciplineOrder
                  disciplineId
                  disciplineName
                }
                competitors {
                  competitorName
                  competitorFirstName
                  competitorLastName
                  competitorId_WA
                  competitorCountryCode
                  competitorCountryName
                  resultCountryName
                  resultCountryCode
                  totalResultMark
                  disciplines {
                    resultMark
                    resultRank
                    resultOrder
                    resultWind
                    summaryRank
                    summaryPoints
                    overallRank
                    record
                    disciplineOrder
                    disciplineId
                    disciplineName
                    combinedPoints
                    pointsTally
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "sexCode": sex_code,
            "combinedDisciplineType": combined_discipline_type,
            "currentCombinedDiscipline": current_combined_discipline,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCombinedPoints.parse_obj(data)

    async def get_event_phase_results(
        self,
        phase_code: Union[Optional[str], UnsetType] = UNSET,
        result_order: Union[Optional[int], UnsetType] = UNSET,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[eventPhaseOrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetEventPhaseResults:
        query = gql(
            """
            query GetEventPhaseResults($phaseCode: String, $resultOrder: Int, $eventId: Int, $orderBy: eventPhaseOrderByEnum, $orderDirection: OrderDirectionEnum) {
              getEventPhaseResults(
                phaseCode: $phaseCode
                resultOrder: $resultOrder
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                combinedType
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                result {
                  id
                  updatedOn
                  competitorId
                  teamId
                  competitorName
                  competitorCountryCode
                  competitorCountryName
                  competitorBirthDate
                  competitorTypeCode
                  resultCountryCode
                  resultMark
                  resultRank
                  resultOrder
                  unitId
                  unitCode
                  unitName
                  unitTypeCode
                  unitDateAndTime
                  eventID
                  phaseID
                  standingPoints
                  discipline {
                    updatedOn
                    hash
                    _id
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  competitorFirstName
                  competitorLastName
                  resultCountryName
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "phaseCode": phase_code,
            "resultOrder": result_order,
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventPhaseResults.parse_obj(data)

    async def get_event_phase_result_detail(
        self,
        country_code: Union[Optional[str], UnsetType] = UNSET,
        event_id: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetEventPhaseResultDetail:
        query = gql(
            """
            query GetEventPhaseResultDetail($countryCode: String, $eventId: Int) {
              getEventPhaseResultDetail(countryCode: $countryCode, eventId: $eventId) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                combinedType
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                result {
                  id
                  updatedOn
                  competitorId
                  teamId
                  competitorName
                  competitorCountryCode
                  competitorCountryName
                  competitorBirthDate
                  competitorTypeCode
                  resultCountryCode
                  resultMark
                  resultRank
                  resultOrder
                  unitId
                  unitCode
                  unitName
                  unitTypeCode
                  unitDateAndTime
                  eventID
                  phaseID
                  standingPoints
                  discipline {
                    updatedOn
                    hash
                    _id
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  competitorFirstName
                  competitorLastName
                  resultCountryName
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "countryCode": country_code,
            "eventId": event_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventPhaseResultDetail.parse_obj(data)

    async def get_event_team_standings(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[TeamStandingOrderBy], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetEventTeamStandings:
        query = gql(
            """
            query GetEventTeamStandings($eventId: Int, $orderBy: TeamStandingOrderBy, $orderDirection: OrderDirectionEnum) {
              getEventTeamStandings(
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                eventId
                rank
                teamName
                teamCountryCode
                teamId
                teamId_WA
                eventId_WA
                eventSubCategoryCode
                sexCode
                sexName
                standingMark
                eventTeamStandingOrder
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventTeamStandings.parse_obj(data)

    async def get_event_team_standing_details(
        self,
        team_id: Union[Optional[int], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetEventTeamStandingDetails:
        query = gql(
            """
            query GetEventTeamStandingDetails($teamId: Int, $orderDirection: OrderDirectionEnum) {
              getEventTeamStandingDetails(teamId: $teamId, orderDirection: $orderDirection) {
                id
                updatedOn
                hash
                teamStandingsId
                teamStandingDetailOrder
                eventId
                sexCode
                sexName
                rank
                resultRank
                resultMark
                record
                standingPoints
                teamId
                teamName
                teamCountryCode
                standingMark
                competitorId_WA
                eventId_WA
                teamId_WA
                competitorId
                competitor {
                  _id
                  updatedOn
                  hash
                  typeCode
                  firstName
                  lastName
                  information
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthDateStr
                  urlSlug
                  representativeTypeCode
                  representativeId
                  competitorId_WA
                  name
                  countryUrlSlug
                  sexNameUrlSlug
                  friendlyName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                }
                discipline {
                  _id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "teamId": team_id,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventTeamStandingDetails.parse_obj(data)

    async def get_event_timetable(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[eventPhaseOrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetEventTimetable:
        query = gql(
            """
            query GetEventTimetable($eventId: Int, $orderBy: eventPhaseOrderByEnum, $orderDirection: OrderDirectionEnum) {
              getEventTimetable(
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                phaseCode
                phaseName
                eventID
                phaseDateAndTime
                sexCode
                sexName
                discipline {
                  updatedOn
                  hash
                  _id
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
                isStartlistPublished
                isResultPublished
                isPhaseSummaryPublished
                isTeamStandingPublished
                combinedDisciplineOrder
                phaseOrder
                phaseSessionName
                phaseSessionOrder
                status
                hasTime
                eventId_WA
                primaryPhaseOrder
                isPointsPublished
                phaseNameUrlSlug
                sexNameUrlSlug
                unitName
                unitTypeName
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEventTimetable.parse_obj(data)

    async def get_events(
        self,
        sub_category_name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        circuit_type_code: Union[Optional[str], UnsetType] = UNSET,
        order_by: Union[Optional[OrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetEvents:
        query = gql(
            """
            query GetEvents($subCategoryNameUrlSlug: String, $circuitTypeCode: String, $orderBy: OrderByEnum, $orderDirection: OrderDirectionEnum, $limit: Int, $offset: Int) {
              getEvents(
                subCategoryNameUrlSlug: $subCategoryNameUrlSlug
                circuitTypeCode: $circuitTypeCode
                orderBy: $orderBy
                orderDirection: $orderDirection
                limit: $limit
                offset: $offset
              ) {
                id
                updatedOn
                name
                startDate
                endDate
                hash
                venue
                countryCode
                countryName
                areaCode
                areaName
                ageCode
                indoorOutdoor
                categoryCode
                categoryName
                categoryOrder
                subCategoryCode
                subCategoryName
                showWebLiveBanner
                subCategoryOrder
                classCode
                classOrder
                isPublished
                hasCompDocResults
                nameUrlSlug
                startDateYear
                circuits {
                  UpdatedOn
                  hash
                  circuitCode
                  circuitTypeCode
                  circuitName
                  season
                  circuitOrder
                  circuitTypeName
                }
                areaNameUrlSlug
                categoryNameUrlSlug
                subCategoryNameUrlSlug
                disciplineCodes
                eventId_WA
                hasTimetable
                page {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
                eventStartDateTime
                eventEndDateTime
                venueTimezone
              }
            }
            """
        )
        variables: dict[str, object] = {
            "subCategoryNameUrlSlug": sub_category_name_url_slug,
            "circuitTypeCode": circuit_type_code,
            "orderBy": order_by,
            "orderDirection": order_direction,
            "limit": limit,
            "offset": offset,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetEvents.parse_obj(data)

    async def get_waw_event(
        self,
        name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        id: Union[Optional[int], UnsetType] = UNSET,
        circuit_type_code: Union[Optional[str], UnsetType] = UNSET,
        sub_category_name_url_slug: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetWawEvent:
        query = gql(
            """
            query GetWawEvent($nameUrlSlug: String, $id: Int, $circuitTypeCode: String, $subCategoryNameUrlSlug: String) {
              getWawEvent(
                nameUrlSlug: $nameUrlSlug
                id: $id
                circuitTypeCode: $circuitTypeCode
                subCategoryNameUrlSlug: $subCategoryNameUrlSlug
              ) {
                id
                updatedOn
                name
                startDate
                endDate
                hash
                venue
                countryCode
                countryName
                areaCode
                areaName
                ageCode
                indoorOutdoor
                categoryCode
                categoryName
                categoryOrder
                subCategoryCode
                subCategoryName
                showWebLiveBanner
                subCategoryOrder
                classCode
                classOrder
                isPublished
                hasCompDocResults
                nameUrlSlug
                startDateYear
                circuits {
                  UpdatedOn
                  hash
                  circuitCode
                  circuitTypeCode
                  circuitName
                  season
                  circuitOrder
                  circuitTypeName
                }
                areaNameUrlSlug
                categoryNameUrlSlug
                subCategoryNameUrlSlug
                disciplineCodes
                eventId_WA
                hasTimetable
                page {
                  id
                  typeId
                  language
                  title
                  competitionId
                  eventId
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  siteId
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  seoDescription
                  slug
                  publishedById
                  publishedByName
                  published
                  contentModules {
                    moduleType
                    language
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    eventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    athleteIds
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    socialLinks
                    lifestyleLinks {
                      articleId
                      title
                      subtitle
                      url
                    }
                    featureLinks {
                      name
                      url
                    }
                    minisiteId
                    minisitePage {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    locationId
                    locations {
                      locationId
                      headline
                      description
                      link
                      imageId
                      imageEdited
                    }
                    eventId
                    tags
                    videos {
                      thumbnailImageId
                      thumbnailImageEdited
                      title
                      description
                      time
                      video
                    }
                    banners {
                      imageId
                      url
                      imageEdited
                      pageId
                    }
                    slides {
                      articleId
                      articleTitle
                      articleSlug
                      imageId
                      imageEdited
                      textPosition
                      colour
                      url
                      standfirst
                      linkUrl
                      subtitle
                      title
                      videoUrl
                      readMoreLink
                      headline
                      strapline
                      readMoreText
                      date
                      subheadline
                    }
                    sections {
                      title
                      show
                    }
                    description
                    eventName
                    tagId
                    moreNewsLink
                    moreNewsText
                    colour
                    imageEdited
                    textPosition
                    textColour
                    title
                    topTitle
                    bottomTitle
                    subtitle
                    category
                    standfirst
                    url
                    buttonText
                    imagePosition
                    backgroundColor
                    showTimestamp
                    content
                    parentId
                    eventIdWa
                    layout
                    slug
                    videoIds
                    videoPlaylistId
                    relatedVideos {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                    videoId
                    relatedVideo {
                      id
                      contentId
                      publishedById
                      publishedByName
                      published
                      language
                      gatedContent
                      campaignId
                      tags
                      title
                      thumbnailId
                      thumbnailEdited
                      videoId
                      playerId
                      tagId
                      standFirst
                    }
                  }
                  gatedContent
                  campaignId
                  campaign {
                    id
                    name
                    tag
                    type
                    description
                    thankYouMessage
                    alreadySignedMessage
                    closeDate
                    redirectUrl
                    tagUserFriendlyName
                    backgroundImageEdited
                    headerImageEdited
                    visibleOnPreferenceCenter
                    shortForm
                    topLevelBucketId
                  }
                }
                eventStartDateTime
                eventEndDateTime
                venueTimezone
              }
            }
            """
        )
        variables: dict[str, object] = {
            "nameUrlSlug": name_url_slug,
            "id": id,
            "circuitTypeCode": circuit_type_code,
            "subCategoryNameUrlSlug": sub_category_name_url_slug,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawEvent.parse_obj(data)

    async def get_waw_event_country_list(
        self,
        name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        id: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetWawEventCountryList:
        query = gql(
            """
            query GetWawEventCountryList($nameUrlSlug: String, $id: Int) {
              getWawEventCountryList(nameUrlSlug: $nameUrlSlug, id: $id) {
                letter
                countries {
                  name
                  code
                  slug
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"nameUrlSlug": name_url_slug, "id": id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawEventCountryList.parse_obj(data)

    async def get_filter_types(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        language: Union[Optional[str], UnsetType] = UNSET,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetFilterTypes:
        query = gql(
            """
            query GetFilterTypes($limit: Int, $offset: Int, $language: String, $minisiteId: String) {
              getFilterTypes(
                limit: $limit
                offset: $offset
                language: $language
                minisiteId: $minisiteId
              ) {
                id
                contentId
                published
                publishedById
                publishedByName
                filters {
                  id
                  contentId
                  typeId
                  type {
                    id
                    contentId
                    published
                    publishedById
                    publishedByName
                    filters {
                      id
                      contentId
                      typeId
                      published
                      publishedById
                      publishedByName
                      language
                      title
                      slug
                    }
                    language
                    title
                    slug
                    typeId
                    siteId
                  }
                  published
                  publishedById
                  publishedByName
                  language
                  title
                  slug
                }
                language
                title
                slug
                typeId
                siteId
              }
            }
            """
        )
        variables: dict[str, object] = {
            "limit": limit,
            "offset": offset,
            "language": language,
            "minisiteId": minisite_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetFilterTypes.parse_obj(data)

    async def get_all_gold_tour_events(self) -> GetAllGoldTourEvents:
        query = gql(
            """
            query GetAllGoldTourEvents {
              getAllGoldTourEvents {
                events {
                  NameofEvent
                  NameofLocation
                  YoutubeVideoId
                  EventDate
                }
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetAllGoldTourEvents.parse_obj(data)

    async def get_latest_qualified_competitors(
        self,
        competition_id: int,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetLatestQualifiedCompetitors:
        query = gql(
            """
            query GetLatestQualifiedCompetitors($competitionId: Int!, $limit: Int, $offset: Int) {
              getLatestQualifiedCompetitors(
                competitionId: $competitionId
                limit: $limit
                offset: $offset
              ) {
                moduleTitle
                moduleSubtitle
                competitionName
                competitionYear
                columns {
                  heading
                  align
                  field
                }
                qualifications {
                  countryCode
                  eventName
                  mark
                  date
                  competitor {
                    name
                    id
                    urlSlug
                    countryUrlSlug
                    birthDate
                    teamMembers {
                      id
                      name
                      iaafId
                      urlSlug
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "limit": limit,
            "offset": offset,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLatestQualifiedCompetitors.parse_obj(data)

    async def get_championship_qualifications(
        self,
        competition_id: int,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        country: Union[Optional[str], UnsetType] = UNSET,
        qualification_type: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetChampionshipQualifications:
        query = gql(
            """
            query GetChampionshipQualifications($competitionId: Int!, $eventId: Int, $country: String, $qualificationType: String) {
              getChampionshipQualifications(
                competitionId: $competitionId
                eventId: $eventId
                country: $country
                qualificationType: $qualificationType
              ) {
                eventId
                groupByCountry
                entryNumber
                entryStandard
                alternativeEntryStandards {
                  entryStandard
                  event
                }
                maxCompetitorsByCoutnry
                firstQualificationDay
                lastQualificationDay
                rankDate
                firstRankingDay
                lastRankingDay
                numberOfCompetitorsQualifiedByEntryStandard
                numberOfCompetitorsQualifiedByDesignatedCompetition
                numberOfCompetitorsFilledUpByWorldRankings
                numberOfCompetitorsQualifiedByTopList
                numberOfCompetitorsQualifiedByUniversalityPlaces
                qualifications {
                  qualifiedBy
                  qualified
                  qualificationPosition
                  countryPosition
                  name
                  urlSlug
                  iaafId
                  birthDate
                  competitorIaafId
                  result
                  wind
                  venue
                  date
                  countryCode
                  place
                  score
                  calculationId
                  label
                }
                events {
                  genderCode
                  eventId
                  disciplineName
                }
                countries {
                  shortname
                  name
                }
                qualificationTypes {
                  id
                  name
                }
                disciplineName
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "eventId": event_id,
            "country": country,
            "qualificationType": qualification_type,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetChampionshipQualifications.parse_obj(data)

    async def get_leading_athletes(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        country_of_residence: Union[Optional[str], UnsetType] = UNSET,
        preferred_country: Union[Optional[str], UnsetType] = UNSET,
        all: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetLeadingAthletes:
        query = gql(
            """
            query GetLeadingAthletes($limit: Int, $countryOfResidence: String, $preferredCountry: String, $all: Boolean) {
              getLeadingAthletes(
                limit: $limit
                countryOfResidence: $countryOfResidence
                preferredCountry: $preferredCountry
                all: $all
              ) {
                eventResults {
                  eventName
                  environment
                  ageCategory
                  season
                  disciplineUrlSlug
                  disciplineTypeUrlSlug
                  sexCode
                  results {
                    mark
                    countryCode
                    competitor {
                      name
                      id
                      urlSlug
                      countryUrlSlug
                      birthDate
                    }
                    primaryMediaId
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "limit": limit,
            "countryOfResidence": country_of_residence,
            "preferredCountry": preferred_country,
            "all": all,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLeadingAthletes.parse_obj(data)

    async def get_live_blog_posts(
        self,
        parent_id: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[OrderByLiveBlogPostEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetLiveBlogPosts:
        query = gql(
            """
            query GetLiveBlogPosts($parentId: String, $limit: Int, $offset: Int, $orderBy: OrderByLiveBlogPostEnum, $orderDirection: OrderDirectionEnum) {
              getLiveBlogPosts(
                parentId: $parentId
                limit: $limit
                offset: $offset
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                parentId
                postId
                language
                title
                imageId
                imageEdited
                text
                dateTime
              }
            }
            """
        )
        variables: dict[str, object] = {
            "parentId": parent_id,
            "limit": limit,
            "offset": offset,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetLiveBlogPosts.parse_obj(data)

    async def get_article_locations(
        self,
        minisite_id: Union[Optional[str], UnsetType] = UNSET,
        tags: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
    ) -> GetArticleLocations:
        query = gql(
            """
            query GetArticleLocations($minisiteId: String, $tags: [String]) {
              getArticleLocations(minisiteId: $minisiteId, tags: $tags) {
                id
                name
                latitude
                longitude
              }
            }
            """
        )
        variables: dict[str, object] = {"minisiteId": minisite_id, "tags": tags}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetArticleLocations.parse_obj(data)

    async def get_medals(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[medalsOrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        country_code: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetMedals:
        query = gql(
            """
            query GetMedals($eventId: Int, $orderBy: medalsOrderByEnum, $orderDirection: OrderDirectionEnum, $countryCode: String) {
              getMedals(
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
                countryCode: $countryCode
              ) {
                id
                updatedOn
                hash
                eventId
                eventId_WA
                countryCode
                medalRank
                silver
                gold
                bronze
                total
                eventMedalTableOrder
                country {
                  updatedOn
                  hash
                  _id
                  countryName
                  countryOrder
                  areaCode
                  areaName
                  areaOrder
                  isValid
                  areaNameUrlSlug
                  countryNameUrlSlug
                }
                eventSubCategoryCode
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
            "countryCode": country_code,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMedals.parse_obj(data)

    async def get_waw_medal_details(
        self,
        medal_table_id: Union[Optional[int], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetWawMedalDetails:
        query = gql(
            """
            query GetWawMedalDetails($medalTableId: Int, $orderDirection: OrderDirectionEnum) {
              getWawMedalDetails(medalTableId: $medalTableId, orderDirection: $orderDirection) {
                id
                updatedOn
                hash
                medalTableId
                typeId
                disciplineCode
                sexCode
                resultId
                resultMark
                eventId
                phaseId
                medalDate
                detailsOrder
                competitorId
                eventId_WA
                competitorId_WA
                competitor {
                  _id
                  updatedOn
                  hash
                  typeCode
                  firstName
                  lastName
                  information
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthDateStr
                  urlSlug
                  representativeTypeCode
                  representativeId
                  competitorId_WA
                  name
                  countryUrlSlug
                  sexNameUrlSlug
                  friendlyName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                }
                discipline {
                  _id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "medalTableId": medal_table_id,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawMedalDetails.parse_obj(data)

    async def get_medias(
        self,
        ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        related_event_name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        types: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        order_by: Union[Optional[OrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetMedias:
        query = gql(
            """
            query GetMedias($ids: [String], $RelatedEventNameUrlSlug: String, $types: [Int], $orderBy: OrderByEnum, $orderDirection: OrderDirectionEnum, $limit: Int, $offset: Int) {
              getMedias(
                ids: $ids
                RelatedEventNameUrlSlug: $RelatedEventNameUrlSlug
                types: $types
                orderBy: $orderBy
                orderDirection: $orderDirection
                limit: $limit
                offset: $offset
              ) {
                id
                title
                sEOTitle
                urlSlug
                credit
                showInMedia
                complete
                fileName
                remoteItemCode
                xMLFileName360
                fileNameUrl
                type
                format
                hosting
                relatedLinks
                sourceWidth
                sourceHeight
                availableRatios
                relatedSexCodes
                relatedAgeGroups
                relatedEventPhases
                status
                liveFrom
                createdOn
                updatedOn
                createdById
                updatedById
              }
            }
            """
        )
        variables: dict[str, object] = {
            "ids": ids,
            "RelatedEventNameUrlSlug": related_event_name_url_slug,
            "types": types,
            "orderBy": order_by,
            "orderDirection": order_direction,
            "limit": limit,
            "offset": offset,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMedias.parse_obj(data)

    async def get_new_medias(
        self,
        featured_athlete_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_event_id: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
        related_competition_ids: Union[
            Optional[List[Optional[str]]], UnsetType
        ] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetNewMedias:
        query = gql(
            """
            query GetNewMedias($featuredAthleteIds: [Int], $relatedEventId: [Int], $relatedCompetitionIds: [String], $limit: Int, $offset: Int, $orderDirection: OrderDirectionEnum) {
              getNewMedias(
                featuredAthleteIds: $featuredAthleteIds
                relatedEventId: $relatedEventId
                relatedCompetitionIds: $relatedCompetitionIds
                limit: $limit
                offset: $offset
                orderDirection: $orderDirection
              ) {
                id
                mediaType
                title
                copyright
                fileName
                relatedAthletes
                relatedDisciplines
                relatedCompetitions
                relatedEvents
                isDeleted
                liveFrom
              }
            }
            """
        )
        variables: dict[str, object] = {
            "featuredAthleteIds": featured_athlete_ids,
            "relatedEventId": related_event_id,
            "relatedCompetitionIds": related_competition_ids,
            "limit": limit,
            "offset": offset,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetNewMedias.parse_obj(data)

    async def get_media(self, id: str) -> GetMedia:
        query = gql(
            """
            query GetMedia($id: String!) {
              getMedia(id: $id) {
                id
                title
                sEOTitle
                urlSlug
                credit
                showInMedia
                complete
                fileName
                remoteItemCode
                xMLFileName360
                fileNameUrl
                type
                format
                hosting
                relatedLinks
                sourceWidth
                sourceHeight
                availableRatios
                relatedSexCodes
                relatedAgeGroups
                relatedEventPhases
                status
                liveFrom
                createdOn
                updatedOn
                createdById
                updatedById
              }
            }
            """
        )
        variables: dict[str, object] = {"id": id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMedia.parse_obj(data)

    async def get_competitors_legacy_primary_media(
        self, ids: List[int]
    ) -> GetCompetitorsLegacyPrimaryMedia:
        query = gql(
            """
            query GetCompetitorsLegacyPrimaryMedia($ids: [Int]!) {
              getCompetitorsLegacyPrimaryMedia(ids: $ids) {
                id
                competitorId
                fileName
              }
            }
            """
        )
        variables: dict[str, object] = {"ids": ids}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetCompetitorsLegacyPrimaryMedia.parse_obj(data)

    async def get_waw_menu(
        self,
        language: Union[Optional[str], UnsetType] = UNSET,
        type: Union[Optional[str], UnsetType] = UNSET,
        related_event_id: Union[Optional[int], UnsetType] = UNSET,
        related_event_name_url_slug: Union[Optional[str], UnsetType] = UNSET,
        site_id: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetWawMenu:
        query = gql(
            """
            query GetWawMenu($language: String, $type: String, $relatedEventId: Int, $relatedEventNameUrlSlug: String, $siteId: String) {
              getWawMenu(
                language: $language
                type: $type
                relatedEventId: $relatedEventId
                relatedEventNameUrlSlug: $relatedEventNameUrlSlug
                siteId: $siteId
              ) {
                id
                title
                type
                isVisible
                eventId
                event {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                items {
                  title
                  isVisible
                  pageId
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  items {
                    title
                    isVisible
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    items {
                      title
                      isVisible
                      pageId
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "language": language,
            "type": type,
            "relatedEventId": related_event_id,
            "relatedEventNameUrlSlug": related_event_name_url_slug,
            "siteId": site_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawMenu.parse_obj(data)

    async def results_by_athlete(
        self,
        athlete_ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        country_of_residence: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        preferred_country: Union[Optional[str], UnsetType] = UNSET,
    ) -> ResultsByAthlete:
        query = gql(
            """
            query ResultsByAthlete($athleteIds: [String], $countryOfResidence: String, $limit: Int, $preferredCountry: String) {
              resultsByAthlete(
                athleteIds: $athleteIds
                countryOfResidence: $countryOfResidence
                limit: $limit
                preferredCountry: $preferredCountry
              ) {
                results {
                  athlete {
                    birthDate
                    country
                    iaafId
                    id
                    name
                    urlSlug
                  }
                  competition
                  date
                  discipline
                  mark
                  matchType
                  place
                  race
                  team
                  venue
                }
                parameters {
                  athleteIds
                  countryOfResidence
                  limit
                  preferredCountry
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "athleteIds": athlete_ids,
            "countryOfResidence": country_of_residence,
            "limit": limit,
            "preferredCountry": preferred_country,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return ResultsByAthlete.parse_obj(data)

    async def competitions_by_country(
        self,
        country_of_residence: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        preferred_country: Union[Optional[str], UnsetType] = UNSET,
    ) -> CompetitionsByCountry:
        query = gql(
            """
            query CompetitionsByCountry($countryOfResidence: String, $limit: Int, $preferredCountry: String) {
              competitionsByCountry(
                countryOfResidence: $countryOfResidence
                limit: $limit
                preferredCountry: $preferredCountry
              ) {
                results {
                  area
                  competitionGroup
                  dateRange
                  disciplines
                  endDate
                  hasResults
                  hasStartlist
                  id
                  matchType
                  name
                  rankingCategory
                  startDate
                  undeterminedCompetitionPeriod
                  venue
                }
                parameters {
                  countryOfResidence
                  limit
                  preferredCountry
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "countryOfResidence": country_of_residence,
            "limit": limit,
            "preferredCountry": preferred_country,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return CompetitionsByCountry.parse_obj(data)

    async def my_athletes(
        self,
        country_of_residence: Union[Optional[str], UnsetType] = UNSET,
        athlete_ids: Union[Optional[List[Optional[str]]], UnsetType] = UNSET,
        preferred_country: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
    ) -> MyAthletes:
        query = gql(
            """
            query MyAthletes($countryOfResidence: String, $athleteIds: [String], $preferredCountry: String, $limit: Int) {
              myAthletes(
                countryOfResidence: $countryOfResidence
                athleteIds: $athleteIds
                preferredCountry: $preferredCountry
                limit: $limit
              ) {
                id
                iaafId
                name
                country
                urlSlug
                birthDate
                typeCode
                isFollowed
                primaryMediaId
                primaryMediaId2
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "countryOfResidence": country_of_residence,
            "athleteIds": athlete_ids,
            "preferredCountry": preferred_country,
            "limit": limit,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return MyAthletes.parse_obj(data)

    async def get_on_this_day(
        self, limit: Union[Optional[int], UnsetType] = UNSET
    ) -> GetOnThisDay:
        query = gql(
            """
            query GetOnThisDay($limit: Int) {
              getOnThisDay(limit: $limit) {
                moduleTitle
                moduleSubtitle
                results {
                  id
                  category
                  title
                  body
                  competitorId
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetOnThisDay.parse_obj(data)

    async def get_page(
        self,
        language: str,
        url_slug: Union[Optional[str], UnsetType] = UNSET,
        related_event_id: Union[Optional[int], UnsetType] = UNSET,
        type_id: Union[Optional[str], UnsetType] = UNSET,
        site_id: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetPage:
        query = gql(
            """
            query GetPage($urlSlug: String, $relatedEventId: Int, $language: String!, $typeId: String, $siteId: String) {
              getPage(
                urlSlug: $urlSlug
                relatedEventId: $relatedEventId
                language: $language
                typeId: $typeId
                siteId: $siteId
              ) {
                id
                typeId
                language
                title
                competitionId
                eventId
                event {
                  id
                  updatedOn
                  name
                  startDate
                  endDate
                  hash
                  venue
                  countryCode
                  countryName
                  areaCode
                  areaName
                  ageCode
                  indoorOutdoor
                  categoryCode
                  categoryName
                  categoryOrder
                  subCategoryCode
                  subCategoryName
                  showWebLiveBanner
                  subCategoryOrder
                  classCode
                  classOrder
                  isPublished
                  hasCompDocResults
                  nameUrlSlug
                  startDateYear
                  circuits {
                    UpdatedOn
                    hash
                    circuitCode
                    circuitTypeCode
                    circuitName
                    season
                    circuitOrder
                    circuitTypeName
                  }
                  areaNameUrlSlug
                  categoryNameUrlSlug
                  subCategoryNameUrlSlug
                  disciplineCodes
                  eventId_WA
                  hasTimetable
                  page {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  eventStartDateTime
                  eventEndDateTime
                  venueTimezone
                }
                siteId
                minisite {
                  id
                  name
                  logoId
                  logo {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  logoEdited
                  featureImageId
                  featureImage {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  featureImageEdited
                  theme
                  defaultSponsorIds
                  defaultSponsors {
                    id
                    eventId
                    type
                    name
                    url
                    logoScale
                    lightBgLogoId
                    lightBgLogo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    lightBgLogoEdited
                    darkBgLogoId
                    darkBgLogo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    darkBgLogoEdited
                  }
                  sponsorIds
                  sponsors {
                    id
                    eventId
                    type
                    name
                    url
                    logoScale
                    lightBgLogoId
                    lightBgLogo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    lightBgLogoEdited
                    darkBgLogoId
                    darkBgLogo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    darkBgLogoEdited
                  }
                  eventId
                  primaryColor
                  secondaryColor
                  tertiaryColor
                  additionalColours
                  languageCodes
                }
                seoDescription
                slug
                publishedById
                publishedByName
                published
                contentModules {
                  moduleType
                  language
                  relatedArticleIds
                  relatedArticles {
                    id
                    title
                    body
                    contentId
                    standFirst
                    standfirst
                    backgroundColour
                    seoDescription
                    sEOTitle
                    seoTitle
                    urlSlug
                    slug
                    campaignId
                    relatedUrls
                    liveFrom
                    articleType
                    featureImageId
                    featureImageEdited
                    hideOnTheMainSite
                    imageEdited
                    mediaIds
                    relatedMedia {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    blogUpdated
                    liveBlog
                    language
                    relatedCompetitorIds
                    relatedCompetitors {
                      id
                      iaafId
                      firstName
                      lastName
                      friendlyName
                      fullName
                      friendlyNameLetter
                      friendlyNameFirst3Letter
                      sexCode
                      sexName
                      countryCode
                      countryName
                      birthDate
                      birthPlace
                      birthPlaceCountryName
                      sexNameUrlSlug
                      countryUrlSlug
                      birthPlaceCountryUrlSlug
                      birthCountryCode
                      primaryMediaId
                      primaryMediaEdited
                      urlSlug
                      representativeId
                      biography
                      twitterLink
                      instagramLink
                      facebookLink
                      transfersOfAllegiance
                      aaId
                      countryFullName
                      familyName
                      givenName
                      birthDateStr
                      facebookUsername
                      twitterUsername
                      instagramUsername
                      mediaIds
                    }
                    relatedDisciplineCodes
                    relatedDiscipline {
                      id
                      updatedOn
                      hash
                      name
                      typeCode
                      typeName
                      typeOrder
                      order
                      isTrack
                      isField
                      isRoad
                      isCombined
                      isWalk
                      isIndoor
                      isReaction
                      isOutdoor
                      isWind
                      isRelay
                      isValidIAAF
                      nameUrlSlug
                      typeNameUrlSlug
                    }
                    relatedCompetitionIds
                    relatedCompetitions {
                      id
                      name
                      circuitTypeCode
                      eventSubCategoryCode
                      description
                      circuitCode
                      urlSlug
                      order
                      category
                      about
                      primaryMediaId
                      relatedMediaIds
                      logoLightId
                      logoDarkId
                      styleOverrides
                      relatedInfo
                      nextEventStartDate
                      pageId
                    }
                    relatedEventIds
                    relatedEvents {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    relatedArticleIds
                    relatedArticles {
                      id
                      title
                      body
                      contentId
                      standFirst
                      standfirst
                      backgroundColour
                      seoDescription
                      sEOTitle
                      seoTitle
                      urlSlug
                      slug
                      campaignId
                      relatedUrls
                      liveFrom
                      articleType
                      featureImageId
                      featureImageEdited
                      hideOnTheMainSite
                      imageEdited
                      mediaIds
                      eventId
                      blogUpdated
                      liveBlog
                      language
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      relatedCompetitionIds
                      relatedEventIds
                      relatedArticleIds
                      relatedMinisiteIds
                      relatedCountryCodes
                      relatedRegionCodes
                      tags
                      published
                      columns
                      publishedById
                      publishedByName
                      relatedArticlesBackgroundColor
                      gatedContent
                    }
                    relatedMinisiteIds
                    relatedMinisitePages {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    relatedCountryCodes
                    relatedRegionCodes
                    tags
                    relatedLinks {
                      displayText
                      url
                    }
                    published
                    columns
                    publishedById
                    publishedByName
                    relatedArticlesBackgroundColor
                    contentModules {
                      moduleType
                      title
                      backgroundColor
                      layout
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                  }
                  eventIds
                  relatedEvents {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                  relatedCompetitorIds
                  relatedCompetitors {
                    id
                    iaafId
                    firstName
                    lastName
                    friendlyName
                    fullName
                    friendlyNameLetter
                    friendlyNameFirst3Letter
                    sexCode
                    sexName
                    countryCode
                    countryName
                    birthDate
                    birthPlace
                    birthPlaceCountryName
                    sexNameUrlSlug
                    countryUrlSlug
                    birthPlaceCountryUrlSlug
                    birthCountryCode
                    primaryMediaId
                    primaryMediaEdited
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                    urlSlug
                    representativeId
                    biography
                    twitterLink
                    instagramLink
                    facebookLink
                    transfersOfAllegiance
                    aaId
                    countryFullName
                    familyName
                    givenName
                    birthDateStr
                    facebookUsername
                    twitterUsername
                    instagramUsername
                    mediaIds
                  }
                  relatedDisciplineCodes
                  relatedDiscipline {
                    id
                    updatedOn
                    hash
                    name
                    typeCode
                    typeName
                    typeOrder
                    order
                    isTrack
                    isField
                    isRoad
                    isCombined
                    isWalk
                    isIndoor
                    isReaction
                    isOutdoor
                    isWind
                    isRelay
                    isValidIAAF
                    nameUrlSlug
                    typeNameUrlSlug
                  }
                  athleteIds
                  mediaIds
                  relatedMedia {
                    id
                    mediaType
                    title
                    copyright
                    fileName
                    relatedAthletes
                    relatedDisciplines
                    relatedCompetitions
                    relatedEvents
                    isDeleted
                    liveFrom
                  }
                  socialLinks
                  lifestyleLinks {
                    articleId
                    title
                    subtitle
                    url
                  }
                  featureLinks {
                    name
                    url
                  }
                  minisiteId
                  minisitePage {
                    id
                    typeId
                    language
                    title
                    competitionId
                    eventId
                    event {
                      id
                      updatedOn
                      name
                      startDate
                      endDate
                      hash
                      venue
                      countryCode
                      countryName
                      areaCode
                      areaName
                      ageCode
                      indoorOutdoor
                      categoryCode
                      categoryName
                      categoryOrder
                      subCategoryCode
                      subCategoryName
                      showWebLiveBanner
                      subCategoryOrder
                      classCode
                      classOrder
                      isPublished
                      hasCompDocResults
                      nameUrlSlug
                      startDateYear
                      areaNameUrlSlug
                      categoryNameUrlSlug
                      subCategoryNameUrlSlug
                      disciplineCodes
                      eventId_WA
                      hasTimetable
                      eventStartDateTime
                      eventEndDateTime
                      venueTimezone
                    }
                    siteId
                    minisite {
                      id
                      name
                      logoId
                      logoEdited
                      featureImageId
                      featureImageEdited
                      theme
                      defaultSponsorIds
                      sponsorIds
                      eventId
                      primaryColor
                      secondaryColor
                      tertiaryColor
                      additionalColours
                      languageCodes
                    }
                    seoDescription
                    slug
                    publishedById
                    publishedByName
                    published
                    contentModules {
                      moduleType
                      language
                      relatedArticleIds
                      eventIds
                      relatedCompetitorIds
                      relatedDisciplineCodes
                      athleteIds
                      mediaIds
                      socialLinks
                      minisiteId
                      locationId
                      eventId
                      tags
                      description
                      eventName
                      tagId
                      moreNewsLink
                      moreNewsText
                      colour
                      imageEdited
                      textPosition
                      textColour
                      title
                      topTitle
                      bottomTitle
                      subtitle
                      category
                      standfirst
                      url
                      buttonText
                      imagePosition
                      backgroundColor
                      showTimestamp
                      content
                      parentId
                      eventIdWa
                      layout
                      slug
                      videoIds
                      videoPlaylistId
                      videoId
                    }
                    gatedContent
                    campaignId
                    campaign {
                      id
                      name
                      tag
                      type
                      description
                      thankYouMessage
                      alreadySignedMessage
                      closeDate
                      redirectUrl
                      tagUserFriendlyName
                      backgroundImageEdited
                      headerImageEdited
                      visibleOnPreferenceCenter
                      shortForm
                      topLevelBucketId
                    }
                  }
                  minisite {
                    id
                    name
                    logoId
                    logo {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    logoEdited
                    featureImageId
                    featureImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    featureImageEdited
                    theme
                    defaultSponsorIds
                    defaultSponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    sponsorIds
                    sponsors {
                      id
                      eventId
                      type
                      name
                      url
                      logoScale
                      lightBgLogoId
                      lightBgLogoEdited
                      darkBgLogoId
                      darkBgLogoEdited
                    }
                    eventId
                    primaryColor
                    secondaryColor
                    tertiaryColor
                    additionalColours
                    languageCodes
                  }
                  locationId
                  locations {
                    locationId
                    location {
                      id
                      name
                      latitude
                      longitude
                    }
                    headline
                    description
                    link
                    imageId
                    imageEdited
                  }
                  eventId
                  tags
                  videos {
                    thumbnailImageId
                    thumbnailImageEdited
                    thumbnailImage {
                      id
                      mediaType
                      title
                      copyright
                      fileName
                      relatedAthletes
                      relatedDisciplines
                      relatedCompetitions
                      relatedEvents
                      isDeleted
                      liveFrom
                    }
                    title
                    description
                    time
                    video
                  }
                  banners {
                    imageId
                    url
                    imageEdited
                    pageId
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                  }
                  slides {
                    articleId
                    articleTitle
                    articleSlug
                    imageId
                    imageEdited
                    textPosition
                    colour
                    url
                    standfirst
                    linkUrl
                    subtitle
                    title
                    videoUrl
                    readMoreLink
                    headline
                    strapline
                    readMoreText
                    date
                    subheadline
                  }
                  sections {
                    title
                    show
                    links {
                      name
                      url
                      pageId
                      fileId
                    }
                  }
                  description
                  eventName
                  tagId
                  moreNewsLink
                  moreNewsText
                  colour
                  imageEdited
                  textPosition
                  textColour
                  title
                  topTitle
                  bottomTitle
                  subtitle
                  category
                  standfirst
                  url
                  buttonText
                  imagePosition
                  backgroundColor
                  showTimestamp
                  content
                  parentId
                  eventIdWa
                  layout
                  slug
                  videoIds
                  videoPlaylistId
                  relatedVideos {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                  videoId
                  relatedVideo {
                    id
                    contentId
                    publishedById
                    publishedByName
                    published
                    language
                    gatedContent
                    campaignId
                    tags
                    title
                    thumbnailId
                    thumbnailEdited
                    videoId
                    playerId
                    tagId
                    standFirst
                  }
                }
                gatedContent
                campaignId
                campaign {
                  id
                  name
                  tag
                  type
                  description
                  thankYouMessage
                  alreadySignedMessage
                  closeDate
                  redirectUrl
                  tagUserFriendlyName
                  backgroundImageEdited
                  headerImageEdited
                  visibleOnPreferenceCenter
                  shortForm
                  topLevelBucketId
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "urlSlug": url_slug,
            "relatedEventId": related_event_id,
            "language": language,
            "typeId": type_id,
            "siteId": site_id,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetPage.parse_obj(data)

    async def get_waw_placing_tables(
        self,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        order_by: Union[Optional[PlacingTableOrderBy], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetWawPlacingTables:
        query = gql(
            """
            query GetWawPlacingTables($eventId: Int, $orderBy: PlacingTableOrderBy, $orderDirection: OrderDirectionEnum) {
              getWawPlacingTables(
                eventId: $eventId
                orderBy: $orderBy
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                eventId
                rank
                countryName
                countryCode
                gold
                silver
                bronze
                forth
                fifth
                sixth
                seventh
                eighth
                points
                tableOrder
                eventId_WA
                subCategoryCode
              }
            }
            """
        )
        variables: dict[str, object] = {
            "eventId": event_id,
            "orderBy": order_by,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawPlacingTables.parse_obj(data)

    async def get_waw_placing_table_details(
        self,
        placing_table_id: Union[Optional[int], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
    ) -> GetWawPlacingTableDetails:
        query = gql(
            """
            query GetWawPlacingTableDetails($placingTableId: Int, $orderDirection: OrderDirectionEnum) {
              getWawPlacingTableDetails(
                placingTableId: $placingTableId
                orderDirection: $orderDirection
              ) {
                id
                updatedOn
                hash
                placingTableId
                typeId
                typeName
                typeAbbreviation
                disciplineCode
                sexCode
                resultId
                resultMark
                placingPoints
                eventId
                phaseId
                competitorId_WA
                eventId_WA
                placingDate
                detailsOrder
                competitorId
                competitor {
                  _id
                  updatedOn
                  hash
                  typeCode
                  firstName
                  lastName
                  information
                  sexCode
                  sexName
                  countryCode
                  countryName
                  birthDate
                  birthDateStr
                  urlSlug
                  representativeTypeCode
                  representativeId
                  competitorId_WA
                  name
                  countryUrlSlug
                  sexNameUrlSlug
                  friendlyName
                  friendlyNameLetter
                  friendlyNameFirst3Letter
                }
                discipline {
                  _id
                  updatedOn
                  hash
                  name
                  typeCode
                  typeName
                  typeOrder
                  order
                  isTrack
                  isField
                  isRoad
                  isCombined
                  isWalk
                  isIndoor
                  isReaction
                  isOutdoor
                  isWind
                  isRelay
                  isValidIAAF
                  nameUrlSlug
                  typeNameUrlSlug
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "placingTableId": placing_table_id,
            "orderDirection": order_direction,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWawPlacingTableDetails.parse_obj(data)

    async def get_pre_championship_highlights(
        self, competition_id: Union[Optional[str], UnsetType] = UNSET
    ) -> GetPreChampionshipHighlights:
        query = gql(
            """
            query GetPreChampionshipHighlights($competitionId: String) {
              getPreChampionshipHighlights(competitionId: $competitionId) {
                events {
                  discipline
                  rankingLeaders {
                    birthDate
                    country
                    iaafId
                    id
                    name
                    urlSlug
                    teamMembers {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    countryUrlSlug
                  }
                  reigningChampions {
                    birthDate
                    country
                    iaafId
                    id
                    name
                    urlSlug
                    teamMembers {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    countryUrlSlug
                  }
                  sex
                  worldLeaders {
                    birthDate
                    country
                    iaafId
                    id
                    name
                    urlSlug
                    teamMembers {
                      birthDate
                      country
                      iaafId
                      id
                      name
                      urlSlug
                      countryUrlSlug
                    }
                    countryUrlSlug
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"competitionId": competition_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetPreChampionshipHighlights.parse_obj(data)

    async def get_ranking_score_calculation(
        self, athlete_id: Union[Optional[int], UnsetType] = UNSET
    ) -> GetRankingScoreCalculation:
        query = gql(
            """
            query GetRankingScoreCalculation($athleteId: Int) {
              getRankingScoreCalculation(athleteId: $athleteId) {
                rankDate
                eventGroup
                male
                athlete
                athleteUrlSlug
                birthDate
                country
                countryFullName
                place
                withWind
                withDrop
                withWorldRecord
                withMonthCorrection
                averagePerformanceScore
                rankingScore
                results {
                  date
                  competition
                  country
                  category
                  disciplineCode
                  disciplineNameUrlSlug
                  typeNameUrlSlug
                  indoor
                  discipline
                  race
                  place
                  mark
                  wind
                  drop
                  resultScore
                  worldRecord
                  placingScore
                  performanceScore
                  monthCorrectionApplied
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"athleteId": athlete_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRankingScoreCalculation.parse_obj(data)

    async def get_result_info(
        self,
        competition_id: Union[Optional[str], UnsetType] = UNSET,
        event_id: Union[Optional[int], UnsetType] = UNSET,
        is_other: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetResultInfo:
        query = gql(
            """
            query GetResultInfo($competitionId: String, $eventId: Int, $isOther: Boolean) {
              getResultInfo(
                competitionId: $competitionId
                eventId: $eventId
                isOther: $isOther
              ) {
                id
                title
                fileName
                infoType
                eventId
                competitionId
              }
            }
            """
        )
        variables: dict[str, object] = {
            "competitionId": competition_id,
            "eventId": event_id,
            "isOther": is_other,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetResultInfo.parse_obj(data)

    async def search_competitors(
        self,
        query: Union[Optional[str], UnsetType] = UNSET,
        gender: Union[Optional[GenderType], UnsetType] = UNSET,
        discipline_code: Union[Optional[str], UnsetType] = UNSET,
        environment: Union[Optional[str], UnsetType] = UNSET,
        country_code: Union[Optional[str], UnsetType] = UNSET,
    ) -> SearchCompetitors:
        query = gql(
            """
            query SearchCompetitors($query: String, $gender: GenderType, $disciplineCode: String, $environment: String, $countryCode: String) {
              searchCompetitors(
                query: $query
                gender: $gender
                disciplineCode: $disciplineCode
                environment: $environment
                countryCode: $countryCode
              ) {
                aaAthleteId
                familyName
                givenName
                birthDate
                disciplines
                iaafId
                gender
                country
                urlSlug
              }
            }
            """
        )
        variables: dict[str, object] = {
            "query": query,
            "gender": gender,
            "disciplineCode": discipline_code,
            "environment": environment,
            "countryCode": country_code,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return SearchCompetitors.parse_obj(data)

    async def get_social_carousel(self) -> GetSocialCarousel:
        query = gql(
            """
            query GetSocialCarousel {
              getSocialCarousel {
                id
                urlSlug
                primaryMediaId
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                socialMediaName
                title
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSocialCarousel.parse_obj(data)

    async def get_spikes(
        self,
        order_by: Union[Optional[OrderByEnum], UnsetType] = UNSET,
        order_direction: Union[Optional[OrderDirectionEnum], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        related_competitor_ids: Union[Optional[List[Optional[int]]], UnsetType] = UNSET,
    ) -> GetSpikes:
        query = gql(
            """
            query GetSpikes($orderBy: OrderByEnum, $orderDirection: OrderDirectionEnum, $limit: Int, $offset: Int, $RelatedCompetitorIds: [Int]) {
              getSpikes(
                orderBy: $orderBy
                orderDirection: $orderDirection
                limit: $limit
                offset: $offset
                RelatedCompetitorIds: $RelatedCompetitorIds
              ) {
                id
                title
                spikesLanguage
                seoTitle
                urlSlug
                metaDescription
                standFirst
                body
                plainTextBody
                articleType
                primaryMediaId
                primaryMedia {
                  id
                  title
                  sEOTitle
                  urlSlug
                  credit
                  showInMedia
                  complete
                  fileName
                  remoteItemCode
                  xMLFileName360
                  fileNameUrl
                  type
                  format
                  hosting
                  relatedLinks
                  sourceWidth
                  sourceHeight
                  availableRatios
                  relatedSexCodes
                  relatedAgeGroups
                  relatedEventPhases
                  status
                  liveFrom
                  createdOn
                  updatedOn
                  createdById
                  updatedById
                }
                relatedDisciplineCodes
                relatedDisciplineTypeNameUrlsSlugs
                relatedCompetitorIds
                relatedCompetitionIds
                relatedTags {
                  id
                  displayText
                  url
                }
                championShip
                featured
                featuredOrder
                status
                liveFrom
                createdOn
                updatedById
                updatedOn
                tags
                tumblrUrl
                spikesArticleType
                liveFromDay
                liveFromMonth
                liveFromYear
              }
            }
            """
        )
        variables: dict[str, object] = {
            "orderBy": order_by,
            "orderDirection": order_direction,
            "limit": limit,
            "offset": offset,
            "RelatedCompetitorIds": related_competitor_ids,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetSpikes.parse_obj(data)

    async def get_top_rankings(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        all: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetTopRankings:
        query = gql(
            """
            query GetTopRankings($limit: Int, $all: Boolean) {
              getTopRankings(limit: $limit, all: $all) {
                moduleTitle
                moduleSubtitle
                rankings {
                  rankingCalculationId
                  competitorId
                  oldCompetitorId
                  competitorName
                  eventName
                  eventUrlSlug
                  sexCode
                  score
                  countryCode
                  primaryMediaId
                  primaryMedia {
                    id
                    title
                    sEOTitle
                    urlSlug
                    credit
                    showInMedia
                    complete
                    fileName
                    remoteItemCode
                    xMLFileName360
                    fileNameUrl
                    type
                    format
                    hosting
                    relatedLinks
                    sourceWidth
                    sourceHeight
                    availableRatios
                    relatedSexCodes
                    relatedAgeGroups
                    relatedEventPhases
                    status
                    liveFrom
                    createdOn
                    updatedOn
                    createdById
                    updatedById
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit, "all": all}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetTopRankings.parse_obj(data)

    async def get_upcoming_competitions(
        self, today: Union[Optional[str], UnsetType] = UNSET
    ) -> GetUpcomingCompetitions:
        query = gql(
            """
            query GetUpcomingCompetitions($today: String) {
              getUpcomingCompetitions(today: $today) {
                competitions {
                  competitionId
                  dateRange
                  endDate
                  isNextEvent
                  name
                  startDate
                  venue
                  urlSlug
                }
                label
              }
            }
            """
        )
        variables: dict[str, object] = {"today": today}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetUpcomingCompetitions.parse_obj(data)

    async def get_video_list(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        language: Union[Optional[str], UnsetType] = UNSET,
        playlist_id: Union[Optional[str], UnsetType] = UNSET,
        type: Union[Optional[str], UnsetType] = UNSET,
        slug: Union[Optional[str], UnsetType] = UNSET,
        is_related_videos: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetVideoList:
        query = gql(
            """
            query GetVideoList($limit: Int, $offset: Int, $language: String, $playlistId: String, $type: String, $slug: String, $isRelatedVideos: Boolean) {
              getVideoList(
                limit: $limit
                offset: $offset
                language: $language
                playlistId: $playlistId
                type: $type
                slug: $slug
                isRelatedVideos: $isRelatedVideos
              ) {
                id
                contentId
                publishedById
                publishedByName
                published
                language
                gatedContent
                campaignId
                tags
                title
                thumbnailId
                thumbnailEdited
                videoId
                playerId
                tagId
                standFirst
              }
            }
            """
        )
        variables: dict[str, object] = {
            "limit": limit,
            "offset": offset,
            "language": language,
            "playlistId": playlist_id,
            "type": type,
            "slug": slug,
            "isRelatedVideos": is_related_videos,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVideoList.parse_obj(data)

    async def get_video_by_id(
        self, content_id: str, language: Union[Optional[str], UnsetType] = UNSET
    ) -> GetVideoById:
        query = gql(
            """
            query GetVideoById($contentId: String!, $language: String) {
              getVideoById(contentId: $contentId, language: $language) {
                id
                contentId
                publishedById
                publishedByName
                published
                language
                gatedContent
                campaignId
                tags
                title
                thumbnailId
                thumbnailEdited
                videoId
                playerId
                tagId
                standFirst
              }
            }
            """
        )
        variables: dict[str, object] = {"contentId": content_id, "language": language}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVideoById.parse_obj(data)

    async def get_videos_total_number(
        self,
        language: Union[Optional[str], UnsetType] = UNSET,
        playlist_id: Union[Optional[str], UnsetType] = UNSET,
        type: Union[Optional[str], UnsetType] = UNSET,
        slug: Union[Optional[str], UnsetType] = UNSET,
    ) -> GetVideosTotalNumber:
        query = gql(
            """
            query GetVideosTotalNumber($language: String, $playlistId: String, $type: String, $slug: String) {
              getVideosTotalNumber(
                language: $language
                playlistId: $playlistId
                type: $type
                slug: $slug
              ) {
                total
              }
            }
            """
        )
        variables: dict[str, object] = {
            "language": language,
            "playlistId": playlist_id,
            "type": type,
            "slug": slug,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVideosTotalNumber.parse_obj(data)

    async def get_video_playlist(self) -> GetVideoPlaylist:
        query = gql(
            """
            query GetVideoPlaylist {
              getVideoPlaylist {
                id
                title
                slug
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVideoPlaylist.parse_obj(data)

    async def get_vocabulary(self, language: str) -> GetVocabulary:
        query = gql(
            """
            query GetVocabulary($language: String!) {
              getVocabulary(language: $language) {
                vocabulary
              }
            }
            """
        )
        variables: dict[str, object] = {"language": language}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVocabulary.parse_obj(data)

    async def get_vote_options(self) -> GetVoteOptions:
        query = gql(
            """
            query GetVoteOptions {
              getVoteOptions {
                id
                order
                voteId
                voteName
                optionYear
                optionAthleteName
                optionDescription
                imageUrl
                votesCount
              }
            }
            """
        )
        variables: dict[str, object] = {}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetVoteOptions.parse_obj(data)

    async def get_users_votes(
        self, user_cognito_id: Union[Optional[str], UnsetType] = UNSET
    ) -> GetUsersVotes:
        query = gql(
            """
            query GetUsersVotes($userCognitoId: String) {
              getUsersVotes(userCognitoId: $userCognitoId) {
                id
                voteId
                userCognitoId
              }
            }
            """
        )
        variables: dict[str, object] = {"userCognitoId": user_cognito_id}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetUsersVotes.parse_obj(data)

    async def get_world_leading_competitors(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        all: Union[Optional[bool], UnsetType] = UNSET,
    ) -> GetWorldLeadingCompetitors:
        query = gql(
            """
            query GetWorldLeadingCompetitors($limit: Int, $all: Boolean) {
              getWorldLeadingCompetitors(limit: $limit, all: $all) {
                moduleTitle
                moduleSubtitle
                eventResults {
                  eventName
                  environment
                  ageCategory
                  season
                  disciplineUrlSlug
                  disciplineTypeUrlSlug
                  sexCode
                  results {
                    mark
                    countryCode
                    competitor {
                      name
                      id
                      urlSlug
                      countryUrlSlug
                      birthDate
                    }
                    primaryMediaId
                    primaryMedia {
                      id
                      title
                      sEOTitle
                      urlSlug
                      credit
                      showInMedia
                      complete
                      fileName
                      remoteItemCode
                      xMLFileName360
                      fileNameUrl
                      type
                      format
                      hosting
                      relatedLinks
                      sourceWidth
                      sourceHeight
                      availableRatios
                      relatedSexCodes
                      relatedAgeGroups
                      relatedEventPhases
                      status
                      liveFrom
                      createdOn
                      updatedOn
                      createdById
                      updatedById
                    }
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit, "all": all}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWorldLeadingCompetitors.parse_obj(data)

    async def get_meta_data(self, types: List[MetaDataTypes]) -> GetMetaData:
        query = gql(
            """
            query GetMetaData($types: [MetaDataTypes]!) {
              getMetaData(types: $types) {
                countryCodes {
                  code
                  name
                }
                disciplineCodes {
                  code
                  name
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"types": types}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetMetaData.parse_obj(data)

    async def get_recent_results(
        self, limit: Union[Optional[int], UnsetType] = UNSET
    ) -> GetRecentResults:
        query = gql(
            """
            query GetRecentResults($limit: Int) {
              getRecentResults(limit: $limit) {
                moduleTitle
                moduleSubtitle
                results {
                  id
                  iaafId
                  name
                  venue
                  startDate
                  endDate
                  event {
                    id
                    updatedOn
                    name
                    startDate
                    endDate
                    hash
                    venue
                    countryCode
                    countryName
                    areaCode
                    areaName
                    ageCode
                    indoorOutdoor
                    categoryCode
                    categoryName
                    categoryOrder
                    subCategoryCode
                    subCategoryName
                    showWebLiveBanner
                    subCategoryOrder
                    classCode
                    classOrder
                    isPublished
                    hasCompDocResults
                    nameUrlSlug
                    startDateYear
                    circuits {
                      UpdatedOn
                      hash
                      circuitCode
                      circuitTypeCode
                      circuitName
                      season
                      circuitOrder
                      circuitTypeName
                    }
                    areaNameUrlSlug
                    categoryNameUrlSlug
                    subCategoryNameUrlSlug
                    disciplineCodes
                    eventId_WA
                    hasTimetable
                    page {
                      id
                      typeId
                      language
                      title
                      competitionId
                      eventId
                      siteId
                      seoDescription
                      slug
                      publishedById
                      publishedByName
                      published
                      gatedContent
                      campaignId
                    }
                    eventStartDateTime
                    eventEndDateTime
                    venueTimezone
                  }
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRecentResults.parse_obj(data)

    async def get_world_rankings(
        self,
        rank_date: Union[Optional[Any], UnsetType] = UNSET,
        event_group: Union[Optional[str], UnsetType] = UNSET,
        region_type: Union[Optional[str], UnsetType] = UNSET,
        region: Union[Optional[str], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        limit_by_country: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetWorldRankings:
        query = gql(
            """
            query GetWorldRankings($rankDate: AWSDateTime, $eventGroup: String, $regionType: String, $region: String, $limit: Int, $limitByCountry: Int) {
              getWorldRankings(
                rankDate: $rankDate
                eventGroup: $eventGroup
                regionType: $regionType
                region: $region
                limit: $limit
                limitByCountry: $limitByCountry
              ) {
                parameters {
                  rankDate
                  gender
                  eventGroup
                  regionType
                  limitedByCountry
                  limit
                }
                rankDate
                eventGroup
                rankings {
                  id
                  place
                  competitorName
                  competitorCountryUrlSlug
                  competitorUrlSlug
                  competitorBirthDate
                  countryCode
                  rankingScore
                  disciplineCodes
                  countryPlace
                  previousId
                  previousPlace
                  previousRankingScore
                }
              }
            }
            """
        )
        variables: dict[str, object] = {
            "rankDate": rank_date,
            "eventGroup": event_group,
            "regionType": region_type,
            "region": region,
            "limit": limit,
            "limitByCountry": limit_by_country,
        }
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWorldRankings.parse_obj(data)

    async def get_random_world_ranking_discipline(
        self,
        limit: Union[Optional[int], UnsetType] = UNSET,
        ranking_limit: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetRandomWorldRankingDiscipline:
        query = gql(
            """
            query GetRandomWorldRankingDiscipline($limit: Int, $rankingLimit: Int) {
              getRandomWorldRankingDiscipline(limit: $limit, rankingLimit: $rankingLimit) {
                name
                displayName
                gender
                urlSlug
                disciplineCodes
                rankings {
                  id
                  place
                  competitorName
                  competitorCountryUrlSlug
                  competitorUrlSlug
                  competitorBirthDate
                  countryCode
                  rankingScore
                  disciplineCodes
                  countryPlace
                  previousId
                  previousPlace
                  previousRankingScore
                }
                query {
                  limit
                  gender
                  eventGroup
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"limit": limit, "rankingLimit": ranking_limit}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetRandomWorldRankingDiscipline.parse_obj(data)

    async def get_world_rankings_changes(
        self,
        all: Union[Optional[bool], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
    ) -> GetWorldRankingsChanges:
        query = gql(
            """
            query GetWorldRankingsChanges($all: Boolean, $limit: Int) {
              getWorldRankingsChanges(all: $all, limit: $limit) {
                moduleTitle
                moduleSubtitle
                changes {
                  rankingCalculationId
                  place
                  previousPlace
                  improvement
                  eventName
                  eventUrlSlug
                  score
                  competitorId
                  competitorName
                  sexCode
                  countryCode
                }
              }
            }
            """
        )
        variables: dict[str, object] = {"all": all, "limit": limit}
        response = await self.execute(query=query, variables=variables)
        data = self.get_data(response)
        return GetWorldRankingsChanges.parse_obj(data)
