content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DerivingStrategies #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE ImportQualifiedPost #-}
  {-# LANGUAGE LambdaCase #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE RecordWildCards #-}
  {-# LANGUAGE StrictData #-}
  {-# LANGUAGE TypeFamilies #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
  {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
  {-# OPTIONS_GHC -fno-warn-unused-binds #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports #-}
  {-# OPTIONS_GHC -fno-warn-unused-matches #-}
  
  -- |
  -- Module      : Gogol.GamesManagement.Internal.Product
  -- Copyright   : (c) 2015-2025 Brendan Hay
  -- License     : Mozilla Public License, v. 2.0.
  -- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
  --               Toni Cebrián <toni@tonicebrian.com>
  -- Stability   : auto-generated
  -- Portability : non-portable (GHC extensions)
  module Gogol.GamesManagement.Internal.Product
    ( -- * AchievementResetAllResponse
      AchievementResetAllResponse (..),
      newAchievementResetAllResponse,
  
      -- * AchievementResetMultipleForAllRequest
      AchievementResetMultipleForAllRequest (..),
      newAchievementResetMultipleForAllRequest,
  
      -- * AchievementResetResponse
      AchievementResetResponse (..),
      newAchievementResetResponse,
  
      -- * EventsResetMultipleForAllRequest
      EventsResetMultipleForAllRequest (..),
      newEventsResetMultipleForAllRequest,
  
      -- * GamesPlayerExperienceInfoResource
      GamesPlayerExperienceInfoResource (..),
      newGamesPlayerExperienceInfoResource,
  
      -- * GamesPlayerLevelResource
      GamesPlayerLevelResource (..),
      newGamesPlayerLevelResource,
  
      -- * HiddenPlayer
      HiddenPlayer (..),
      newHiddenPlayer,
  
      -- * HiddenPlayerList
      HiddenPlayerList (..),
      newHiddenPlayerList,
  
      -- * Player
      Player (..),
      newPlayer,
  
      -- * Player_Name
      Player_Name (..),
      newPlayer_Name,
  
      -- * PlayerScoreResetAllResponse
      PlayerScoreResetAllResponse (..),
      newPlayerScoreResetAllResponse,
  
      -- * PlayerScoreResetResponse
      PlayerScoreResetResponse (..),
      newPlayerScoreResetResponse,
  
      -- * ProfileSettings
      ProfileSettings (..),
      newProfileSettings,
  
      -- * ScoresResetMultipleForAllRequest
      ScoresResetMultipleForAllRequest (..),
      newScoresResetMultipleForAllRequest,
    )
  where
  
  import Gogol.GamesManagement.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | Achievement reset all response.
  --
  -- /See:/ 'newAchievementResetAllResponse' smart constructor.
  data AchievementResetAllResponse = AchievementResetAllResponse
    { -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#achievementResetAllResponse@.
      kind :: (Core.Maybe Core.Text),
      -- | The achievement reset results.
      results :: (Core.Maybe [AchievementResetResponse])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AchievementResetAllResponse' with the minimum fields required to make a request.
  newAchievementResetAllResponse ::
    AchievementResetAllResponse
  newAchievementResetAllResponse =
    AchievementResetAllResponse
      { kind = Core.Nothing,
        results = Core.Nothing
      }
  
  instance Core.FromJSON AchievementResetAllResponse where
    parseJSON =
      Core.withObject
        "AchievementResetAllResponse"
        ( \o ->
            AchievementResetAllResponse
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "results")
        )
  
  instance Core.ToJSON AchievementResetAllResponse where
    toJSON AchievementResetAllResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("results" Core..=) Core.<$> results
            ]
        )
  
  --
  -- /See:/ 'newAchievementResetMultipleForAllRequest' smart constructor.
  data AchievementResetMultipleForAllRequest = AchievementResetMultipleForAllRequest
    { -- | The IDs of achievements to reset.
      achievementIds :: (Core.Maybe [Core.Text]),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#achievementResetMultipleForAllRequest@.
      kind :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AchievementResetMultipleForAllRequest' with the minimum fields required to make a request.
  newAchievementResetMultipleForAllRequest ::
    AchievementResetMultipleForAllRequest
  newAchievementResetMultipleForAllRequest =
    AchievementResetMultipleForAllRequest
      { achievementIds =
          Core.Nothing,
        kind = Core.Nothing
      }
  
  instance Core.FromJSON AchievementResetMultipleForAllRequest where
    parseJSON =
      Core.withObject
        "AchievementResetMultipleForAllRequest"
        ( \o ->
            AchievementResetMultipleForAllRequest
              Core.<$> (o Core..:? "achievement_ids")
              Core.<*> (o Core..:? "kind")
        )
  
  instance Core.ToJSON AchievementResetMultipleForAllRequest where
    toJSON AchievementResetMultipleForAllRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("achievement_ids" Core..=) Core.<$> achievementIds,
              ("kind" Core..=) Core.<$> kind
            ]
        )
  
  -- | An achievement reset response.
  --
  -- /See:/ 'newAchievementResetResponse' smart constructor.
  data AchievementResetResponse = AchievementResetResponse
    { -- | The current state of the achievement. This is the same as the initial state of the achievement. Possible values are: - \"@HIDDEN@\"- Achievement is hidden. - \"@REVEALED@\" - Achievement is revealed. - \"@UNLOCKED@\" - Achievement is unlocked.
      currentState :: (Core.Maybe Core.Text),
      -- | The ID of an achievement for which player state has been updated.
      definitionId :: (Core.Maybe Core.Text),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#achievementResetResponse@.
      kind :: (Core.Maybe Core.Text),
      -- | Flag to indicate if the requested update actually occurred.
      updateOccurred :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AchievementResetResponse' with the minimum fields required to make a request.
  newAchievementResetResponse ::
    AchievementResetResponse
  newAchievementResetResponse =
    AchievementResetResponse
      { currentState = Core.Nothing,
        definitionId = Core.Nothing,
        kind = Core.Nothing,
        updateOccurred = Core.Nothing
      }
  
  instance Core.FromJSON AchievementResetResponse where
    parseJSON =
      Core.withObject
        "AchievementResetResponse"
        ( \o ->
            AchievementResetResponse
              Core.<$> (o Core..:? "currentState")
              Core.<*> (o Core..:? "definitionId")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "updateOccurred")
        )
  
  instance Core.ToJSON AchievementResetResponse where
    toJSON AchievementResetResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentState" Core..=) Core.<$> currentState,
              ("definitionId" Core..=) Core.<$> definitionId,
              ("kind" Core..=) Core.<$> kind,
              ("updateOccurred" Core..=) Core.<$> updateOccurred
            ]
        )
  
  -- | Multiple events reset all request.
  --
  -- /See:/ 'newEventsResetMultipleForAllRequest' smart constructor.
  data EventsResetMultipleForAllRequest = EventsResetMultipleForAllRequest
    { -- | The IDs of events to reset.
      eventIds :: (Core.Maybe [Core.Text]),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#eventsResetMultipleForAllRequest@.
      kind :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EventsResetMultipleForAllRequest' with the minimum fields required to make a request.
  newEventsResetMultipleForAllRequest ::
    EventsResetMultipleForAllRequest
  newEventsResetMultipleForAllRequest =
    EventsResetMultipleForAllRequest
      { eventIds = Core.Nothing,
        kind = Core.Nothing
      }
  
  instance Core.FromJSON EventsResetMultipleForAllRequest where
    parseJSON =
      Core.withObject
        "EventsResetMultipleForAllRequest"
        ( \o ->
            EventsResetMultipleForAllRequest
              Core.<$> (o Core..:? "event_ids")
              Core.<*> (o Core..:? "kind")
        )
  
  instance Core.ToJSON EventsResetMultipleForAllRequest where
    toJSON EventsResetMultipleForAllRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("event_ids" Core..=) Core.<$> eventIds,
              ("kind" Core..=) Core.<$> kind
            ]
        )
  
  -- | 1P\/3P metadata about the player\'s experience.
  --
  -- /See:/ 'newGamesPlayerExperienceInfoResource' smart constructor.
  data GamesPlayerExperienceInfoResource = GamesPlayerExperienceInfoResource
    { -- | The current number of experience points for the player.
      currentExperiencePoints :: (Core.Maybe Core.Int64),
      -- | The current level of the player.
      currentLevel :: (Core.Maybe GamesPlayerLevelResource),
      -- | The timestamp when the player was leveled up, in millis since Unix epoch UTC.
      lastLevelUpTimestampMillis :: (Core.Maybe Core.Int64),
      -- | The next level of the player. If the current level is the maximum level, this should be same as the current level.
      nextLevel :: (Core.Maybe GamesPlayerLevelResource)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GamesPlayerExperienceInfoResource' with the minimum fields required to make a request.
  newGamesPlayerExperienceInfoResource ::
    GamesPlayerExperienceInfoResource
  newGamesPlayerExperienceInfoResource =
    GamesPlayerExperienceInfoResource
      { currentExperiencePoints =
          Core.Nothing,
        currentLevel = Core.Nothing,
        lastLevelUpTimestampMillis = Core.Nothing,
        nextLevel = Core.Nothing
      }
  
  instance Core.FromJSON GamesPlayerExperienceInfoResource where
    parseJSON =
      Core.withObject
        "GamesPlayerExperienceInfoResource"
        ( \o ->
            GamesPlayerExperienceInfoResource
              Core.<$> ( o
                           Core..:? "currentExperiencePoints"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "currentLevel")
              Core.<*> ( o
                           Core..:? "lastLevelUpTimestampMillis"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> (o Core..:? "nextLevel")
        )
  
  instance Core.ToJSON GamesPlayerExperienceInfoResource where
    toJSON GamesPlayerExperienceInfoResource {..} =
      Core.object
        ( Core.catMaybes
            [ ("currentExperiencePoints" Core..=)
                Core.. Core.AsText
                Core.<$> currentExperiencePoints,
              ("currentLevel" Core..=) Core.<$> currentLevel,
              ("lastLevelUpTimestampMillis" Core..=)
                Core.. Core.AsText
                Core.<$> lastLevelUpTimestampMillis,
              ("nextLevel" Core..=) Core.<$> nextLevel
            ]
        )
  
  -- | 1P\/3P metadata about a user\'s level.
  --
  -- /See:/ 'newGamesPlayerLevelResource' smart constructor.
  data GamesPlayerLevelResource = GamesPlayerLevelResource
    { -- | The level for the user.
      level :: (Core.Maybe Core.Int32),
      -- | The maximum experience points for this level.
      maxExperiencePoints :: (Core.Maybe Core.Int64),
      -- | The minimum experience points for this level.
      minExperiencePoints :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'GamesPlayerLevelResource' with the minimum fields required to make a request.
  newGamesPlayerLevelResource ::
    GamesPlayerLevelResource
  newGamesPlayerLevelResource =
    GamesPlayerLevelResource
      { level = Core.Nothing,
        maxExperiencePoints = Core.Nothing,
        minExperiencePoints = Core.Nothing
      }
  
  instance Core.FromJSON GamesPlayerLevelResource where
    parseJSON =
      Core.withObject
        "GamesPlayerLevelResource"
        ( \o ->
            GamesPlayerLevelResource
              Core.<$> (o Core..:? "level")
              Core.<*> ( o
                           Core..:? "maxExperiencePoints"
                           Core.<&> Core.fmap Core.fromAsText
                       )
              Core.<*> ( o
                           Core..:? "minExperiencePoints"
                           Core.<&> Core.fmap Core.fromAsText
                       )
        )
  
  instance Core.ToJSON GamesPlayerLevelResource where
    toJSON GamesPlayerLevelResource {..} =
      Core.object
        ( Core.catMaybes
            [ ("level" Core..=) Core.<$> level,
              ("maxExperiencePoints" Core..=)
                Core.. Core.AsText
                Core.<$> maxExperiencePoints,
              ("minExperiencePoints" Core..=)
                Core.. Core.AsText
                Core.<$> minExperiencePoints
            ]
        )
  
  -- | The HiddenPlayer resource.
  --
  -- /See:/ 'newHiddenPlayer' smart constructor.
  data HiddenPlayer = HiddenPlayer
    { -- | Output only. The time this player was hidden.
      hiddenTimeMillis :: (Core.Maybe Core.Int64),
      -- | Output only. Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#hiddenPlayer@.
      kind :: (Core.Maybe Core.Text),
      -- | Output only. The player information.
      player :: (Core.Maybe Player)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HiddenPlayer' with the minimum fields required to make a request.
  newHiddenPlayer ::
    HiddenPlayer
  newHiddenPlayer =
    HiddenPlayer
      { hiddenTimeMillis = Core.Nothing,
        kind = Core.Nothing,
        player = Core.Nothing
      }
  
  instance Core.FromJSON HiddenPlayer where
    parseJSON =
      Core.withObject
        "HiddenPlayer"
        ( \o ->
            HiddenPlayer
              Core.<$> (o Core..:? "hiddenTimeMillis" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "player")
        )
  
  instance Core.ToJSON HiddenPlayer where
    toJSON HiddenPlayer {..} =
      Core.object
        ( Core.catMaybes
            [ ("hiddenTimeMillis" Core..=)
                Core.. Core.AsText
                Core.<$> hiddenTimeMillis,
              ("kind" Core..=) Core.<$> kind,
              ("player" Core..=) Core.<$> player
            ]
        )
  
  -- | A list of hidden players.
  --
  -- /See:/ 'newHiddenPlayerList' smart constructor.
  data HiddenPlayerList = HiddenPlayerList
    { -- | The players.
      items :: (Core.Maybe [HiddenPlayer]),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#hiddenPlayerList@.
      kind :: (Core.Maybe Core.Text),
      -- | The pagination token for the next page of results.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HiddenPlayerList' with the minimum fields required to make a request.
  newHiddenPlayerList ::
    HiddenPlayerList
  newHiddenPlayerList =
    HiddenPlayerList
      { items = Core.Nothing,
        kind = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON HiddenPlayerList where
    parseJSON =
      Core.withObject
        "HiddenPlayerList"
        ( \o ->
            HiddenPlayerList
              Core.<$> (o Core..:? "items")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON HiddenPlayerList where
    toJSON HiddenPlayerList {..} =
      Core.object
        ( Core.catMaybes
            [ ("items" Core..=) Core.<$> items,
              ("kind" Core..=) Core.<$> kind,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | A Player resource.
  --
  -- /See:/ 'newPlayer' smart constructor.
  data Player = Player
    { -- | The base URL for the image that represents the player.
      avatarImageUrl :: (Core.Maybe Core.Text),
      -- | The url to the landscape mode player banner image.
      bannerUrlLandscape :: (Core.Maybe Core.Text),
      -- | The url to the portrait mode player banner image.
      bannerUrlPortrait :: (Core.Maybe Core.Text),
      -- | The name to display for the player.
      displayName :: (Core.Maybe Core.Text),
      -- | An object to represent Play Game experience information for the player.
      experienceInfo :: (Core.Maybe GamesPlayerExperienceInfoResource),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#player@.
      kind :: (Core.Maybe Core.Text),
      -- | An object representation of the individual components of the player\'s name. For some players, these fields may not be present.
      name :: (Core.Maybe Player_Name),
      -- | The player ID that was used for this player the first time they signed into the game in question. This is only populated for calls to player.get for the requesting player, only if the player ID has subsequently changed, and only to clients that support remapping player IDs.
      originalPlayerId :: (Core.Maybe Core.Text),
      -- | The ID of the player.
      playerId :: (Core.Maybe Core.Text),
      -- | The player\'s profile settings. Controls whether or not the player\'s profile is visible to other players.
      profileSettings :: (Core.Maybe ProfileSettings),
      -- | The player\'s title rewarded for their game activities.
      title :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Player' with the minimum fields required to make a request.
  newPlayer ::
    Player
  newPlayer =
    Player
      { avatarImageUrl = Core.Nothing,
        bannerUrlLandscape = Core.Nothing,
        bannerUrlPortrait = Core.Nothing,
        displayName = Core.Nothing,
        experienceInfo = Core.Nothing,
        kind = Core.Nothing,
        name = Core.Nothing,
        originalPlayerId = Core.Nothing,
        playerId = Core.Nothing,
        profileSettings = Core.Nothing,
        title = Core.Nothing
      }
  
  instance Core.FromJSON Player where
    parseJSON =
      Core.withObject
        "Player"
        ( \o ->
            Player
              Core.<$> (o Core..:? "avatarImageUrl")
              Core.<*> (o Core..:? "bannerUrlLandscape")
              Core.<*> (o Core..:? "bannerUrlPortrait")
              Core.<*> (o Core..:? "displayName")
              Core.<*> (o Core..:? "experienceInfo")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "originalPlayerId")
              Core.<*> (o Core..:? "playerId")
              Core.<*> (o Core..:? "profileSettings")
              Core.<*> (o Core..:? "title")
        )
  
  instance Core.ToJSON Player where
    toJSON Player {..} =
      Core.object
        ( Core.catMaybes
            [ ("avatarImageUrl" Core..=) Core.<$> avatarImageUrl,
              ("bannerUrlLandscape" Core..=) Core.<$> bannerUrlLandscape,
              ("bannerUrlPortrait" Core..=) Core.<$> bannerUrlPortrait,
              ("displayName" Core..=) Core.<$> displayName,
              ("experienceInfo" Core..=) Core.<$> experienceInfo,
              ("kind" Core..=) Core.<$> kind,
              ("name" Core..=) Core.<$> name,
              ("originalPlayerId" Core..=) Core.<$> originalPlayerId,
              ("playerId" Core..=) Core.<$> playerId,
              ("profileSettings" Core..=) Core.<$> profileSettings,
              ("title" Core..=) Core.<$> title
            ]
        )
  
  -- | An object representation of the individual components of the player\'s name. For some players, these fields may not be present.
  --
  -- /See:/ 'newPlayer_Name' smart constructor.
  data Player_Name = Player_Name
    { -- | The family name of this player. In some places, this is known as the last name.
      familyName :: (Core.Maybe Core.Text),
      -- | The given name of this player. In some places, this is known as the first name.
      givenName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Player_Name' with the minimum fields required to make a request.
  newPlayer_Name ::
    Player_Name
  newPlayer_Name =
    Player_Name {familyName = Core.Nothing, givenName = Core.Nothing}
  
  instance Core.FromJSON Player_Name where
    parseJSON =
      Core.withObject
        "Player_Name"
        ( \o ->
            Player_Name
              Core.<$> (o Core..:? "familyName")
              Core.<*> (o Core..:? "givenName")
        )
  
  instance Core.ToJSON Player_Name where
    toJSON Player_Name {..} =
      Core.object
        ( Core.catMaybes
            [ ("familyName" Core..=) Core.<$> familyName,
              ("givenName" Core..=) Core.<$> givenName
            ]
        )
  
  -- | A list of leaderboard reset resources.
  --
  -- /See:/ 'newPlayerScoreResetAllResponse' smart constructor.
  data PlayerScoreResetAllResponse = PlayerScoreResetAllResponse
    { -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#playerScoreResetAllResponse@.
      kind :: (Core.Maybe Core.Text),
      -- | The leaderboard reset results.
      results :: (Core.Maybe [PlayerScoreResetResponse])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PlayerScoreResetAllResponse' with the minimum fields required to make a request.
  newPlayerScoreResetAllResponse ::
    PlayerScoreResetAllResponse
  newPlayerScoreResetAllResponse =
    PlayerScoreResetAllResponse
      { kind = Core.Nothing,
        results = Core.Nothing
      }
  
  instance Core.FromJSON PlayerScoreResetAllResponse where
    parseJSON =
      Core.withObject
        "PlayerScoreResetAllResponse"
        ( \o ->
            PlayerScoreResetAllResponse
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "results")
        )
  
  instance Core.ToJSON PlayerScoreResetAllResponse where
    toJSON PlayerScoreResetAllResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("results" Core..=) Core.<$> results
            ]
        )
  
  -- | A list of reset leaderboard entry resources.
  --
  -- /See:/ 'newPlayerScoreResetResponse' smart constructor.
  data PlayerScoreResetResponse = PlayerScoreResetResponse
    { -- | The ID of an leaderboard for which player state has been updated.
      definitionId :: (Core.Maybe Core.Text),
      -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#playerScoreResetResponse@.
      kind :: (Core.Maybe Core.Text),
      -- | The time spans of the updated score. Possible values are: - \"@ALL_TIME@\" - The score is an all-time score. - \"@WEEKLY@\" - The score is a weekly score. - \"@DAILY@\" - The score is a daily score.
      resetScoreTimeSpans :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PlayerScoreResetResponse' with the minimum fields required to make a request.
  newPlayerScoreResetResponse ::
    PlayerScoreResetResponse
  newPlayerScoreResetResponse =
    PlayerScoreResetResponse
      { definitionId = Core.Nothing,
        kind = Core.Nothing,
        resetScoreTimeSpans = Core.Nothing
      }
  
  instance Core.FromJSON PlayerScoreResetResponse where
    parseJSON =
      Core.withObject
        "PlayerScoreResetResponse"
        ( \o ->
            PlayerScoreResetResponse
              Core.<$> (o Core..:? "definitionId")
              Core.<*> (o Core..:? "kind")
              Core.<*> (o Core..:? "resetScoreTimeSpans")
        )
  
  instance Core.ToJSON PlayerScoreResetResponse where
    toJSON PlayerScoreResetResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("definitionId" Core..=) Core.<$> definitionId,
              ("kind" Core..=) Core.<$> kind,
              ("resetScoreTimeSpans" Core..=) Core.<$> resetScoreTimeSpans
            ]
        )
  
  -- | Profile settings
  --
  -- /See:/ 'newProfileSettings' smart constructor.
  data ProfileSettings = ProfileSettings
    { -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#profileSettings@.
      kind :: (Core.Maybe Core.Text),
      profileVisible :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ProfileSettings' with the minimum fields required to make a request.
  newProfileSettings ::
    ProfileSettings
  newProfileSettings =
    ProfileSettings
      { kind = Core.Nothing,
        profileVisible = Core.Nothing
      }
  
  instance Core.FromJSON ProfileSettings where
    parseJSON =
      Core.withObject
        "ProfileSettings"
        ( \o ->
            ProfileSettings
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "profileVisible")
        )
  
  instance Core.ToJSON ProfileSettings where
    toJSON ProfileSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("profileVisible" Core..=) Core.<$> profileVisible
            ]
        )
  
  --
  -- /See:/ 'newScoresResetMultipleForAllRequest' smart constructor.
  data ScoresResetMultipleForAllRequest = ScoresResetMultipleForAllRequest
    { -- | Uniquely identifies the type of this resource. Value is always the fixed string @gamesManagement#scoresResetMultipleForAllRequest@.
      kind :: (Core.Maybe Core.Text),
      -- | The IDs of leaderboards to reset.
      leaderboardIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ScoresResetMultipleForAllRequest' with the minimum fields required to make a request.
  newScoresResetMultipleForAllRequest ::
    ScoresResetMultipleForAllRequest
  newScoresResetMultipleForAllRequest =
    ScoresResetMultipleForAllRequest
      { kind = Core.Nothing,
        leaderboardIds = Core.Nothing
      }
  
  instance Core.FromJSON ScoresResetMultipleForAllRequest where
    parseJSON =
      Core.withObject
        "ScoresResetMultipleForAllRequest"
        ( \o ->
            ScoresResetMultipleForAllRequest
              Core.<$> (o Core..:? "kind")
              Core.<*> (o Core..:? "leaderboard_ids")
        )
  
  instance Core.ToJSON ScoresResetMultipleForAllRequest where
    toJSON ScoresResetMultipleForAllRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("kind" Core..=) Core.<$> kind,
              ("leaderboard_ids" Core..=) Core.<$> leaderboardIds
            ]
        )
  