Options
All
  • Public
  • Public/Protected
  • All
Menu

@rpglogs/api-sdk

Index

Enumerations

Type aliases

Variables

Functions

Type aliases

Bracket

Bracket: { __typename?: "Bracket"; bucket: Scalars["Float"]; max: Scalars["Float"]; min: Scalars["Float"]; type?: Maybe<Scalars["String"]> }

A bracket description for a given raid zone. Brackets have a minimum value, maximum value, and a bucket that can be used to establish all of the possible brackets. The type field indicates what the brackets represent, e.g., item levels or game patches, etc.

Type declaration

  • Optional __typename?: "Bracket"
  • bucket: Scalars["Float"]

    A float representing the value to increment when moving from bracket 1 to bracket N, etc.

  • max: Scalars["Float"]

    An integer representing the value used by bracket N when there are a total of N brackets, etc.

  • min: Scalars["Float"]

    An integer representing the minimum value used by bracket number 1, etc.

  • Optional type?: Maybe<Scalars["String"]>

    The localized name of the bracket type.

Character

Character: { __typename?: "Character"; canonicalID: Scalars["Int"]; classID: Scalars["Int"]; encounterRankings?: Maybe<Scalars["JSON"]>; faction: GameFaction; gameData?: Maybe<Scalars["JSON"]>; guildRank: Scalars["Int"]; guilds?: Maybe<Maybe<Guild>[]>; hidden: Scalars["Boolean"]; id: Scalars["Int"]; level: Scalars["Int"]; name: Scalars["String"]; recentReports?: Maybe<ReportPagination>; server: Server; zoneRankings?: Maybe<Scalars["JSON"]> }

A player character. Characters can earn individual rankings and appear in reports.

Type declaration

  • Optional __typename?: "Character"
  • canonicalID: Scalars["Int"]

    The canonical ID of the character. If a character renames or transfers, then the canonical id can be used to identify the most recent version of the character.

  • classID: Scalars["Int"]

    The class id of the character.

  • Optional encounterRankings?: Maybe<Scalars["JSON"]>

    Encounter rankings information for a character, filterable to specific zones, bosses, metrics, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • faction: GameFaction

    The faction of the character.

  • Optional gameData?: Maybe<Scalars["JSON"]>

    Cached game data such as gear for the character. This data was fetched from the appropriate source (Blizzard APIs for WoW, Lodestone for FF). This call will only return a cached copy of the data if it exists already. It will not go out to Blizzard or Lodestone to fetch a new copy.

  • guildRank: Scalars["Int"]

    The guild rank of the character in their primary guild. This is not the user rank on the site, but the rank according to the game data, e.g., a Warcraft guild rank or an FFXIV Free Company rank.

  • Optional guilds?: Maybe<Maybe<Guild>[]>

    All guilds that the character belongs to.

  • hidden: Scalars["Boolean"]

    Whether or not the character has all its rankings hidden.

  • id: Scalars["Int"]

    The ID of the character.

  • level: Scalars["Int"]

    The level of the character.

  • name: Scalars["String"]

    The name of the character.

  • Optional recentReports?: Maybe<ReportPagination>

    Recent reports for the character.

  • server: Server

    The server that the character belongs to.

  • Optional zoneRankings?: Maybe<Scalars["JSON"]>

    Rankings information for a character, filterable to specific zones, bosses, metrics, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

CharacterData

CharacterData: { __typename?: "CharacterData"; character?: Maybe<Character>; characters?: Maybe<CharacterPagination> }

The CharacterData object enables the retrieval of single characters or filtered collections of characters.

Type declaration

  • Optional __typename?: "CharacterData"
  • Optional character?: Maybe<Character>

    Obtain a specific character either by id or by name/server_slug/server_region.

  • Optional characters?: Maybe<CharacterPagination>

    A collection of characters for a specific guild.

CharacterDataCharacterArgs

CharacterDataCharacterArgs: { id?: Maybe<Scalars["Int"]>; name?: Maybe<Scalars["String"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]> }

The CharacterData object enables the retrieval of single characters or filtered collections of characters.

Type declaration

CharacterDataCharactersArgs

CharacterDataCharactersArgs: { guildID?: Maybe<Scalars["Int"]>; limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The CharacterData object enables the retrieval of single characters or filtered collections of characters.

Type declaration

CharacterEncounterRankingsArgs

CharacterEncounterRankingsArgs: { byBracket?: Maybe<Scalars["Boolean"]>; compare?: Maybe<RankingCompareType>; difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; includeCombatantInfo?: Maybe<Scalars["Boolean"]>; includePrivateLogs?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; partition?: Maybe<Scalars["Int"]>; role?: Maybe<RoleType>; size?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]>; timeframe?: Maybe<RankingTimeframeType> }

A player character. Characters can earn individual rankings and appear in reports.

Type declaration

CharacterGameDataArgs

CharacterGameDataArgs: { specID?: Maybe<Scalars["Int"]> }

A player character. Characters can earn individual rankings and appear in reports.

Type declaration

CharacterPagination

CharacterPagination: { __typename?: "CharacterPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<Character>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "CharacterPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<Character>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

CharacterRecentReportsArgs

CharacterRecentReportsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

A player character. Characters can earn individual rankings and appear in reports.

Type declaration

CharacterZoneRankingsArgs

CharacterZoneRankingsArgs: { byBracket?: Maybe<Scalars["Boolean"]>; compare?: Maybe<RankingCompareType>; difficulty?: Maybe<Scalars["Int"]>; includePrivateLogs?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; partition?: Maybe<Scalars["Int"]>; role?: Maybe<RoleType>; size?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]>; timeframe?: Maybe<RankingTimeframeType>; zoneID?: Maybe<Scalars["Int"]> }

A player character. Characters can earn individual rankings and appear in reports.

Type declaration

Difficulty

Difficulty: { __typename?: "Difficulty"; id: Scalars["Int"]; name: Scalars["String"]; sizes?: Maybe<Maybe<Scalars["Int"]>[]> }

A single difficulty for a given raid zone. Difficulties have an integer value representing the actual difficulty, a localized name that describes the difficulty level, and a list of valid sizes for the difficulty level.

Type declaration

  • Optional __typename?: "Difficulty"
  • id: Scalars["Int"]

    An integer representing a specific difficulty level within a zone. For example, in World of Warcraft, this could be Mythic. In FF, it could be Savage, etc.

  • name: Scalars["String"]

    The localized name for the difficulty level.

  • Optional sizes?: Maybe<Maybe<Scalars["Int"]>[]>

    A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.

Encounter

Encounter: { __typename?: "Encounter"; characterRankings?: Maybe<Scalars["JSON"]>; fightRankings?: Maybe<Scalars["JSON"]>; id: Scalars["Int"]; journalID: Scalars["Int"]; name: Scalars["String"]; zone: Zone }

A single encounter for the game.

Type declaration

  • Optional __typename?: "Encounter"
  • Optional characterRankings?: Maybe<Scalars["JSON"]>

    Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • Optional fightRankings?: Maybe<Scalars["JSON"]>

    Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • id: Scalars["Int"]

    The ID of the encounter.

  • journalID: Scalars["Int"]

    The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.

  • name: Scalars["String"]

    The localized name of the encounter.

  • zone: Zone

    The zone that this encounter is found in.

EncounterCharacterRankingsArgs

EncounterCharacterRankingsArgs: { bracket?: Maybe<Scalars["Int"]>; className?: Maybe<Scalars["String"]>; covenantID?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; filter?: Maybe<Scalars["String"]>; includeCombatantInfo?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; page?: Maybe<Scalars["Int"]>; partition?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; size?: Maybe<Scalars["Int"]>; soulbindID?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]> }

A single encounter for the game.

Type declaration

EncounterFightRankingsArgs

EncounterFightRankingsArgs: { bracket?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; filter?: Maybe<Scalars["String"]>; metric?: Maybe<FightRankingMetricType>; page?: Maybe<Scalars["Int"]>; partition?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; size?: Maybe<Scalars["Int"]> }

A single encounter for the game.

Type declaration

Exact

Exact<T>: {[ K in keyof T]: T[K] }

Type parameters

  • T: {}

Expansion

Expansion: { __typename?: "Expansion"; id: Scalars["Int"]; name: Scalars["String"]; zones?: Maybe<Maybe<Zone>[]> }

A single expansion for the game.

Type declaration

  • Optional __typename?: "Expansion"
  • id: Scalars["Int"]

    The ID of the expansion.

  • name: Scalars["String"]

    The localized name of the expansion.

  • Optional zones?: Maybe<Maybe<Zone>[]>

    The zones (e.g., raids and dungeons) supported for this expansion.

GameAbility

GameAbility: { __typename?: "GameAbility"; icon?: Maybe<Scalars["String"]>; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single ability for the game.

Type declaration

  • Optional __typename?: "GameAbility"
  • Optional icon?: Maybe<Scalars["String"]>

    The icon for the ability.

  • id: Scalars["Int"]

    The ID of the ability.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the ability. Will be null if no localization information exists for the ability.

GameAbilityPagination

GameAbilityPagination: { __typename?: "GameAbilityPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameAbility>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameAbilityPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameAbility>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameAchievement

GameAchievement: { __typename?: "GameAchievement"; icon?: Maybe<Scalars["String"]>; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single achievement for the game.

Type declaration

  • Optional __typename?: "GameAchievement"
  • Optional icon?: Maybe<Scalars["String"]>

    The icon for the achievement.

  • id: Scalars["Int"]

    The ID of the achievement.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the achievement. Will be null if no localization information exists for the achievement.

GameAchievementPagination

GameAchievementPagination: { __typename?: "GameAchievementPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameAchievement>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameAchievementPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameAchievement>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameAffix

GameAffix: { __typename?: "GameAffix"; icon?: Maybe<Scalars["String"]>; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single affix for Mythic Keystone dungeons.

Type declaration

  • Optional __typename?: "GameAffix"
  • Optional icon?: Maybe<Scalars["String"]>

    The icon for the affix.

  • id: Scalars["Int"]

    The ID of the affix.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the affix. Will be null if no localization information exists for the affix.

GameClass

GameClass: { __typename?: "GameClass"; id: Scalars["Int"]; name: Scalars["String"]; slug: Scalars["String"]; specs?: Maybe<Maybe<Spec>[]> }

A single player class for the game.

Type declaration

  • Optional __typename?: "GameClass"
  • id: Scalars["Int"]

    An integer used to identify the class.

  • name: Scalars["String"]

    The localized name of the class.

  • slug: Scalars["String"]

    A slug used to identify the class.

  • Optional specs?: Maybe<Maybe<Spec>[]>

    The specs supported by the class.

GameData

GameData: { __typename?: "GameData"; abilities?: Maybe<GameAbilityPagination>; ability?: Maybe<GameAbility>; achievement?: Maybe<GameAchievement>; achievements?: Maybe<GameAchievementPagination>; affix?: Maybe<GameAffix>; affixes?: Maybe<Maybe<GameAffix>[]>; class?: Maybe<GameClass>; classes?: Maybe<Maybe<GameClass>[]>; enchant?: Maybe<GameEnchant>; enchants?: Maybe<GameEnchantPagination>; factions?: Maybe<Maybe<GameFaction>[]>; item?: Maybe<GameItem>; items?: Maybe<GameItemPagination>; map?: Maybe<GameMap>; maps?: Maybe<GameMapPagination>; npc?: Maybe<GameNpc>; npcs?: Maybe<GameNpcPagination>; zone?: Maybe<GameZone>; zones?: Maybe<GameZonePagination> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataAbilitiesArgs

GameDataAbilitiesArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataAbilityArgs

GameDataAbilityArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataAchievementArgs

GameDataAchievementArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataAchievementsArgs

GameDataAchievementsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataAffixArgs

GameDataAffixArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataClassArgs

GameDataClassArgs: { faction_id?: Maybe<Scalars["Int"]>; id?: Maybe<Scalars["Int"]>; zone_id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataClassesArgs

GameDataClassesArgs: { faction_id?: Maybe<Scalars["Int"]>; zone_id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataEnchantArgs

GameDataEnchantArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataEnchantsArgs

GameDataEnchantsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataItemArgs

GameDataItemArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataItemsArgs

GameDataItemsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataMapArgs

GameDataMapArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataMapsArgs

GameDataMapsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataNpcArgs

GameDataNpcArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataNpcsArgs

GameDataNpcsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataZoneArgs

GameDataZoneArgs: { id?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameDataZonesArgs

GameDataZonesArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

The game object contains collections of data such as NPCs, classes, abilities, items, maps, etc. Game data only changes when major game patches are released, so you should cache results for as long as possible and only update when new content is released for the game.

Type declaration

GameEnchant

GameEnchant: { __typename?: "GameEnchant"; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single enchant for the game.

Type declaration

  • Optional __typename?: "GameEnchant"
  • id: Scalars["Int"]

    The ID of the enchant.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the enchant. Will be null if no localization information exists for the enchant.

GameEnchantPagination

GameEnchantPagination: { __typename?: "GameEnchantPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameEnchant>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameEnchantPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameEnchant>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameFaction

GameFaction: { __typename?: "GameFaction"; id: Scalars["Int"]; name: Scalars["String"] }

A faction that a player or guild can belong to. Factions have an integer id used to identify them throughout the API and a localized name describing the faction.

Type declaration

  • Optional __typename?: "GameFaction"
  • id: Scalars["Int"]

    An integer representing the faction id.

  • name: Scalars["String"]

    The localized name of the faction.

GameItem

GameItem: { __typename?: "GameItem"; icon?: Maybe<Scalars["String"]>; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single item for the game.

Type declaration

  • Optional __typename?: "GameItem"
  • Optional icon?: Maybe<Scalars["String"]>

    The icon for the item.

  • id: Scalars["Int"]

    The ID of the item.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the item. Will be null if no localization information exists for the item.

GameItemPagination

GameItemPagination: { __typename?: "GameItemPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameItem>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameItemPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameItem>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameItemSet

GameItemSet: { __typename?: "GameItemSet"; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single item set for the game.

Type declaration

  • Optional __typename?: "GameItemSet"
  • id: Scalars["Int"]

    The ID of the item set.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the item set. Will be null if no localization information exists for the item set.

GameMap

GameMap: { __typename?: "GameMap"; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single map for the game.

Type declaration

  • Optional __typename?: "GameMap"
  • id: Scalars["Int"]

    The ID of the map.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the map. Will be null if no localization information exists for the map.

GameMapPagination

GameMapPagination: { __typename?: "GameMapPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameMap>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameMapPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameMap>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameNpc

GameNpc: { __typename?: "GameNPC"; id: Scalars["Int"]; name?: Maybe<Scalars["String"]> }

A single NPC for the game.

Type declaration

  • Optional __typename?: "GameNPC"
  • id: Scalars["Int"]

    The ID of the NPC.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the NPC. Will be null if no localization information exists for the NPC.

GameNpcPagination

GameNpcPagination: { __typename?: "GameNPCPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameNpc>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameNPCPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameNpc>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GameZone

GameZone: { __typename?: "GameZone"; id: Scalars["Float"]; name?: Maybe<Scalars["String"]> }

A single zone for the game.

Type declaration

  • Optional __typename?: "GameZone"
  • id: Scalars["Float"]

    The ID of the zone.

  • Optional name?: Maybe<Scalars["String"]>

    The localized name of the zone. Will be null if no localization information exists for the zone.

GameZonePagination

GameZonePagination: { __typename?: "GameZonePagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GameZone>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GameZonePagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GameZone>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GetAbilityQuery

GetAbilityQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { ability?: Maybe<{ __typename?: "GameAbility" } & Pick<GameAbility, "id" | "name" | "icon">> }> }

GetAbilityQueryVariables

GetAbilityQueryVariables: Exact<{ id: Scalars["Int"] }>

GetAchievementQuery

GetAchievementQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { achievement?: Maybe<{ __typename?: "GameAchievement" } & Pick<GameAchievement, "id" | "name" | "icon">> }> }

GetAchievementQueryVariables

GetAchievementQueryVariables: Exact<{ id: Scalars["Int"] }>

GetAffixesQuery

GetAffixesQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { affixes?: Maybe<Maybe<{ __typename?: "GameAffix" } & Pick<GameAffix, "id" | "name" | "icon">>[]> }> }

GetAffixesQueryVariables

GetAffixesQueryVariables: Exact<{}>

GetCharacterEncounterRankingsQuery

GetCharacterEncounterRankingsQuery: { __typename?: "Query" } & { characterData?: Maybe<{ __typename?: "CharacterData" } & { character?: Maybe<{ __typename?: "Character" } & Pick<Character, "id" | "name" | "encounterRankings">> }> }

GetCharacterEncounterRankingsQueryVariables

GetCharacterEncounterRankingsQueryVariables: Exact<{ byBracket?: Maybe<Scalars["Boolean"]>; characterId?: Maybe<Scalars["Int"]>; characterName?: Maybe<Scalars["String"]>; characterRegion?: Maybe<Scalars["String"]>; characterServerSlug?: Maybe<Scalars["String"]>; compare?: Maybe<RankingCompareType>; difficulty?: Maybe<Scalars["Int"]>; encounterId: Scalars["Int"]; includeCombatantInfo?: Maybe<Scalars["Boolean"]>; includePrivateLogs?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; partition?: Maybe<Scalars["Int"]>; role?: Maybe<RoleType>; size?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]>; timeframe?: Maybe<RankingTimeframeType> }>

GetCharacterQuery

GetCharacterQuery: { __typename?: "Query" } & { characterData?: Maybe<{ __typename?: "CharacterData" } & { character?: Maybe<{ __typename?: "Character" } & MakeOptional<Pick<Character, "id" | "name" | "level" | "classID" | "guildRank" | "hidden" | "gameData">, "gameData"> & { faction: { __typename?: "GameFaction" } & Pick<GameFaction, "id" | "name">; guilds?: Maybe<Maybe<{ __typename?: "Guild" } & Pick<Guild, "id" | "name">>[]>; server?: Maybe<{ __typename?: "Server" } & Pick<Server, "id" | "name"> & { region: { __typename?: "Region" } & Pick<Region, "id" | "name" | "compactName"> }> }> }> }

GetCharacterQueryVariables

GetCharacterQueryVariables: Exact<{ characterId?: Maybe<Scalars["Int"]>; characterName?: Maybe<Scalars["String"]>; characterServerRegion?: Maybe<Scalars["String"]>; characterServerSlug?: Maybe<Scalars["String"]>; includeGameData: Scalars["Boolean"]; includeGuilds: Scalars["Boolean"]; includeServer: Scalars["Boolean"] }>

GetCharacterZoneRankingsQuery

GetCharacterZoneRankingsQuery: { __typename?: "Query" } & { characterData?: Maybe<{ __typename?: "CharacterData" } & { character?: Maybe<{ __typename?: "Character" } & Pick<Character, "id" | "name" | "zoneRankings">> }> }

GetCharacterZoneRankingsQueryVariables

GetCharacterZoneRankingsQueryVariables: Exact<{ byBracket?: Maybe<Scalars["Boolean"]>; characterId?: Maybe<Scalars["Int"]>; characterName?: Maybe<Scalars["String"]>; characterRegion?: Maybe<Scalars["String"]>; characterServerSlug?: Maybe<Scalars["String"]>; compare?: Maybe<RankingCompareType>; difficulty?: Maybe<Scalars["Int"]>; includePrivateLogs?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; partition?: Maybe<Scalars["Int"]>; role?: Maybe<RoleType>; size?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]>; timeframe?: Maybe<RankingTimeframeType>; zoneId: Scalars["Int"] }>

GetClassesQuery

GetClassesQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { classes?: Maybe<Maybe<{ __typename?: "GameClass" } & Pick<GameClass, "id" | "name" | "slug"> & { specs?: Maybe<Maybe<{ __typename?: "Spec" } & Pick<Spec, "id" | "name" | "slug">>[]> }>[]> }> }

GetClassesQueryVariables

GetClassesQueryVariables: Exact<{}>

GetEnchantQuery

GetEnchantQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { enchant?: Maybe<{ __typename?: "GameEnchant" } & Pick<GameEnchant, "id" | "name">> }> }

GetEnchantQueryVariables

GetEnchantQueryVariables: Exact<{ id: Scalars["Int"] }>

GetEncounterCharacterRankingsQuery

GetEncounterCharacterRankingsQuery: { __typename?: "Query" } & { worldData?: Maybe<{ __typename?: "WorldData" } & { encounter?: Maybe<{ __typename?: "Encounter" } & Pick<Encounter, "id" | "name" | "characterRankings">> }> }

GetEncounterCharacterRankingsQueryVariables

GetEncounterCharacterRankingsQueryVariables: Exact<{ bracket?: Maybe<Scalars["Int"]>; className?: Maybe<Scalars["String"]>; difficulty?: Maybe<Scalars["Int"]>; encounterId: Scalars["Int"]; filter?: Maybe<Scalars["String"]>; includeCombatantInfo?: Maybe<Scalars["Boolean"]>; metric?: Maybe<CharacterRankingMetricType>; page?: Maybe<Scalars["Int"]>; partition?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; size?: Maybe<Scalars["Int"]>; specName?: Maybe<Scalars["String"]> }>

GetEncounterFightRankingsQuery

GetEncounterFightRankingsQuery: { __typename?: "Query" } & { worldData?: Maybe<{ __typename?: "WorldData" } & { encounter?: Maybe<{ __typename?: "Encounter" } & Pick<Encounter, "id" | "name" | "fightRankings">> }> }

GetEncounterFightRankingsQueryVariables

GetEncounterFightRankingsQueryVariables: Exact<{ bracket?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterId: Scalars["Int"]; filter?: Maybe<Scalars["String"]>; metric?: Maybe<FightRankingMetricType>; page?: Maybe<Scalars["Int"]>; partition?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; size?: Maybe<Scalars["Int"]> }>

GetFactionsQuery

GetFactionsQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { factions?: Maybe<Maybe<{ __typename?: "GameFaction" } & Pick<GameFaction, "id" | "name">>[]> }> }

GetFactionsQueryVariables

GetFactionsQueryVariables: Exact<{}>

GetGuildQuery

GetGuildQuery: { __typename?: "Query" } & { guildData?: Maybe<{ __typename?: "GuildData" } & { guild?: Maybe<{ __typename?: "Guild" } & Pick<Guild, "id" | "name" | "description" | "competitionMode" | "stealthMode"> & { attendance?: Maybe<{ __typename?: "GuildAttendancePagination" } & Pick<GuildAttendancePagination, "current_page" | "from" | "to" | "per_page" | "has_more_pages" | "last_page" | "total"> & { data?: Maybe<Maybe<{ __typename?: "GuildAttendance" } & Pick<GuildAttendance, "code" | "startTime"> & { players?: Maybe<Maybe<{ __typename?: "PlayerAttendance" } & Pick<PlayerAttendance, "name" | "type" | "presence">>[]>; zone?: Maybe<{ __typename?: "Zone" } & Pick<Zone, "id" | "name">> }>[]> }>; faction: { __typename?: "GameFaction" } & Pick<GameFaction, "id" | "name">; members?: Maybe<{ __typename?: "CharacterPagination" } & Pick<CharacterPagination, "current_page" | "from" | "to" | "per_page" | "has_more_pages" | "last_page" | "total"> & { data?: Maybe<Maybe<{ __typename?: "Character" } & Pick<Character, "id" | "name" | "guildRank" | "level" | "classID">>[]> }>; server?: Maybe<{ __typename?: "Server" } & Pick<Server, "id" | "name"> & { region: { __typename?: "Region" } & Pick<Region, "id" | "name" | "compactName"> }>; tags?: Maybe<Maybe<{ __typename?: "GuildTag" } & Pick<GuildTag, "id" | "name">>[]> }> }> }

GetGuildQueryVariables

GetGuildQueryVariables: Exact<{ attendanceGuildTagId?: Maybe<Scalars["Int"]>; attendanceLimit?: Maybe<Scalars["Int"]>; attendancePage?: Maybe<Scalars["Int"]>; attendanceZoneId?: Maybe<Scalars["Int"]>; guildId?: Maybe<Scalars["Int"]>; guildName?: Maybe<Scalars["String"]>; guildServerRegion?: Maybe<Scalars["String"]>; guildServerSlug?: Maybe<Scalars["String"]>; includeAttendance: Scalars["Boolean"]; includeMembers: Scalars["Boolean"]; includeServer: Scalars["Boolean"]; includeTags: Scalars["Boolean"]; membersLimit?: Maybe<Scalars["Int"]>; membersPage?: Maybe<Scalars["Int"]> }>

GetGuildReportsQuery

GetGuildReportsQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { reports?: Maybe<{ __typename?: "ReportPagination" } & Pick<ReportPagination, "current_page" | "has_more_pages" | "last_page" | "per_page" | "total" | "from" | "to"> & { data?: Maybe<Maybe<{ __typename?: "Report" } & Pick<Report, "code" | "visibility" | "title" | "startTime" | "endTime" | "revision" | "segments" | "exportedSegments"> & { fights?: Maybe<Maybe<{ __typename?: "ReportFight" } & Pick<ReportFight, "id" | "encounterID" | "name" | "difficulty" | "size" | "startTime" | "endTime" | "fightPercentage" | "bossPercentage" | "lastPhase" | "lastPhaseIsIntermission" | "kill" | "averageItemLevel" | "wipeCalledTime" | "completeRaid" | "keystoneAffixes" | "keystoneBonus" | "keystoneLevel" | "keystoneTime" | "rating" | "layer">>[]>; guildTag?: Maybe<{ __typename?: "GuildTag" } & Pick<GuildTag, "id" | "name">>; owner?: Maybe<{ __typename?: "User" } & Pick<User, "id" | "name">>; zone?: Maybe<{ __typename?: "Zone" } & Pick<Zone, "id" | "name">> }>[]> }> }> }

GetGuildReportsQueryVariables

GetGuildReportsQueryVariables: Exact<{ endTime?: Maybe<Scalars["Float"]>; fightsDifficulty?: Maybe<Scalars["Int"]>; fightsEncounterId?: Maybe<Scalars["Int"]>; fightsFightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; fightsKillType?: Maybe<KillType>; fightsTranslate?: Maybe<Scalars["Boolean"]>; guildId?: Maybe<Scalars["Int"]>; guildName?: Maybe<Scalars["String"]>; guildServerRegion?: Maybe<Scalars["String"]>; guildServerSlug?: Maybe<Scalars["String"]>; guildTagId?: Maybe<Scalars["Int"]>; includeFights: Scalars["Boolean"]; limit: Scalars["Int"]; page?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; zoneId?: Maybe<Scalars["Int"]> }>

GetItemQuery

GetItemQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { item?: Maybe<{ __typename?: "GameItem" } & Pick<GameItem, "id" | "name" | "icon">> }> }

GetItemQueryVariables

GetItemQueryVariables: Exact<{ id: Scalars["Int"] }>

GetNpcQuery

GetNpcQuery: { __typename?: "Query" } & { gameData?: Maybe<{ __typename?: "GameData" } & { npc?: Maybe<{ __typename?: "GameNPC" } & Pick<GameNpc, "id" | "name">> }> }

GetNpcQueryVariables

GetNpcQueryVariables: Exact<{ id: Scalars["Int"] }>

GetProgressRaceQuery

GetProgressRaceQuery: { __typename?: "Query" } & { progressRaceData?: Maybe<{ __typename?: "ProgressRaceData" } & Pick<ProgressRaceData, "progressRace">> }

GetProgressRaceQueryVariables

GetProgressRaceQueryVariables: Exact<{ serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; zoneId?: Maybe<Scalars["Int"]> }>

GetRateLimitQuery

GetRateLimitQuery: { __typename?: "Query" } & { rateLimitData?: Maybe<{ __typename?: "RateLimitData" } & Pick<RateLimitData, "limitPerHour" | "pointsResetIn" | "pointsSpentThisHour">> }

GetRateLimitQueryVariables

GetRateLimitQueryVariables: Exact<{}>

GetReportEventsQuery

GetReportEventsQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code"> & { events?: Maybe<{ __typename?: "ReportEventPaginator" } & Pick<ReportEventPaginator, "nextPageTimestamp" | "data">> }> }> }

GetReportEventsQueryVariables

GetReportEventsQueryVariables: Exact<{ abilityId?: Maybe<Scalars["Float"]>; code: Scalars["String"]; dataType?: Maybe<EventDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterId?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; includeResources?: Maybe<Scalars["Boolean"]>; killType?: Maybe<KillType>; limit?: Maybe<Scalars["Int"]>; sourceClass?: Maybe<Scalars["String"]>; sourceId?: Maybe<Scalars["Int"]>; sourceInstanceId?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetId?: Maybe<Scalars["Int"]>; targetInstanceId?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }>

GetReportFightsQuery

GetReportFightsQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code"> & { fights?: Maybe<Maybe<{ __typename?: "ReportFight" } & MakeOptional<Pick<ReportFight, "id" | "encounterID" | "name" | "difficulty" | "size" | "startTime" | "endTime" | "fightPercentage" | "bossPercentage" | "lastPhase" | "lastPhaseIsIntermission" | "kill" | "friendlyPlayers" | "enemyPlayers" | "averageItemLevel" | "wipeCalledTime" | "completeRaid" | "keystoneAffixes" | "keystoneBonus" | "keystoneLevel" | "keystoneTime" | "rating" | "layer">, "friendlyPlayers" | "enemyPlayers"> & { dungeonPulls?: Maybe<Maybe<{ __typename?: "ReportDungeonPull" } & Pick<ReportDungeonPull, "id" | "encounterID" | "name" | "startTime" | "endTime" | "kill" | "x" | "y"> & { enemyNPCs?: Maybe<Maybe<{ __typename?: "ReportDungeonPullNPC" } & Pick<ReportDungeonPullNpc, "id" | "gameID" | "minimumInstanceID" | "maximumInstanceID" | "minimumInstanceGroupID" | "maximumInstanceGroupID">>[]>; maps?: Maybe<Maybe<{ __typename?: "ReportMap" } & Pick<ReportMap, "id">>[]> }>[]>; enemyNPCs?: Maybe<Maybe<{ __typename?: "ReportFightNPC" } & Pick<ReportFightNpc, "id" | "gameID" | "instanceCount" | "groupCount">>[]>; friendlyNPCs?: Maybe<Maybe<{ __typename?: "ReportFightNPC" } & Pick<ReportFightNpc, "id" | "gameID" | "instanceCount" | "groupCount">>[]>; gameZone?: Maybe<{ __typename?: "GameZone" } & Pick<GameZone, "id" | "name">>; maps?: Maybe<Maybe<{ __typename?: "ReportMap" } & Pick<ReportMap, "id">>[]> }>[]> }> }> }

GetReportFightsQueryVariables

GetReportFightsQueryVariables: Exact<{ code: Scalars["String"]; difficulty?: Maybe<Scalars["Int"]>; encounterId?: Maybe<Scalars["Int"]>; fightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; includeDungeonPulls: Scalars["Boolean"]; includeNpcs: Scalars["Boolean"]; includePlayers: Scalars["Boolean"]; killType?: Maybe<KillType>; translate?: Maybe<Scalars["Boolean"]> }>

GetReportGraphQuery

GetReportGraphQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code" | "graph">> }> }

GetReportGraphQueryVariables

GetReportGraphQueryVariables: Exact<{ abilityId?: Maybe<Scalars["Float"]>; code: Scalars["String"]; dataType?: Maybe<GraphDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterId?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; killType?: Maybe<KillType>; sourceClass?: Maybe<Scalars["String"]>; sourceId?: Maybe<Scalars["Int"]>; sourceInstanceId?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetId?: Maybe<Scalars["Int"]>; targetInstanceId?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; viewBy?: Maybe<ViewType>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }>

GetReportPlayerDetailsQuery

GetReportPlayerDetailsQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code" | "playerDetails">> }> }

GetReportPlayerDetailsQueryVariables

GetReportPlayerDetailsQueryVariables: Exact<{ code: Scalars["String"]; difficulty?: Maybe<Scalars["Int"]>; encounterId?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; killType?: Maybe<KillType>; startTime?: Maybe<Scalars["Float"]>; translate?: Maybe<Scalars["Boolean"]> }>

GetReportRankedCharactersQuery

GetReportRankedCharactersQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code"> & { rankedCharacters?: Maybe<Maybe<{ __typename?: "Character" } & MakeOptional<Pick<Character, "id" | "name" | "level" | "classID" | "guildRank" | "hidden" | "gameData">, "gameData"> & { faction: { __typename?: "GameFaction" } & Pick<GameFaction, "id" | "name">; guilds?: Maybe<Maybe<{ __typename?: "Guild" } & Pick<Guild, "id" | "name">>[]>; server?: Maybe<{ __typename?: "Server" } & Pick<Server, "id" | "name"> & { region: { __typename?: "Region" } & Pick<Region, "id" | "name" | "compactName"> }> }>[]> }> }> }

GetReportRankedCharactersQueryVariables

GetReportRankedCharactersQueryVariables: Exact<{ code?: Maybe<Scalars["String"]>; includeGameData: Scalars["Boolean"]; includeGuilds: Scalars["Boolean"]; includeServer: Scalars["Boolean"] }>

GetReportTableQuery

GetReportTableQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { report?: Maybe<{ __typename?: "Report" } & Pick<Report, "code" | "table">> }> }

GetReportTableQueryVariables

GetReportTableQueryVariables: Exact<{ abilityId?: Maybe<Scalars["Float"]>; code: Scalars["String"]; dataType?: Maybe<TableDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterId?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; killType?: Maybe<KillType>; sourceClass?: Maybe<Scalars["String"]>; sourceId?: Maybe<Scalars["Int"]>; sourceInstanceId?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetId?: Maybe<Scalars["Int"]>; targetInstanceId?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; viewBy?: Maybe<ViewType>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }>

GetUserReportsQuery

GetUserReportsQuery: { __typename?: "Query" } & { reportData?: Maybe<{ __typename?: "ReportData" } & { reports?: Maybe<{ __typename?: "ReportPagination" } & Pick<ReportPagination, "current_page" | "has_more_pages" | "last_page" | "per_page" | "total" | "from" | "to"> & { data?: Maybe<Maybe<{ __typename?: "Report" } & Pick<Report, "code" | "visibility" | "title" | "startTime" | "endTime" | "revision" | "segments" | "exportedSegments"> & { fights?: Maybe<Maybe<{ __typename?: "ReportFight" } & Pick<ReportFight, "id" | "encounterID" | "name" | "difficulty" | "size" | "startTime" | "endTime" | "fightPercentage" | "bossPercentage" | "lastPhase" | "lastPhaseIsIntermission" | "kill" | "averageItemLevel" | "wipeCalledTime" | "completeRaid" | "keystoneAffixes" | "keystoneBonus" | "keystoneLevel" | "keystoneTime" | "rating" | "layer">>[]>; owner?: Maybe<{ __typename?: "User" } & Pick<User, "id" | "name">>; zone?: Maybe<{ __typename?: "Zone" } & Pick<Zone, "id" | "name">> }>[]> }> }> }

GetUserReportsQueryVariables

GetUserReportsQueryVariables: Exact<{ endTime?: Maybe<Scalars["Float"]>; fightsDifficulty?: Maybe<Scalars["Int"]>; fightsEncounterId?: Maybe<Scalars["Int"]>; fightsFightIds?: Maybe<Maybe<Scalars["Int"]>[] | Maybe<Scalars["Int"]>>; fightsKillType?: Maybe<KillType>; fightsTranslate?: Maybe<Scalars["Boolean"]>; includeFights: Scalars["Boolean"]; limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; userId?: Maybe<Scalars["Int"]>; zoneId?: Maybe<Scalars["Int"]> }>

GetZonesQuery

GetZonesQuery: { __typename?: "Query" } & { worldData?: Maybe<{ __typename?: "WorldData" } & { zones?: Maybe<Maybe<{ __typename?: "Zone" } & Pick<Zone, "id" | "name" | "frozen"> & { brackets?: Maybe<{ __typename?: "Bracket" } & Pick<Bracket, "type" | "min" | "max" | "bucket">>; difficulties?: Maybe<Maybe<{ __typename?: "Difficulty" } & Pick<Difficulty, "id" | "name" | "sizes">>[]>; encounters?: Maybe<Maybe<{ __typename?: "Encounter" } & Pick<Encounter, "id" | "name">>[]>; expansion: { __typename?: "Expansion" } & Pick<Expansion, "id" | "name"> }>[]> }> }

GetZonesQueryVariables

GetZonesQueryVariables: Exact<{}>

Guild

Guild: { __typename?: "Guild"; attendance: GuildAttendancePagination; competitionMode: Scalars["Boolean"]; description: Scalars["String"]; faction: GameFaction; id: Scalars["Int"]; members: CharacterPagination; name: Scalars["String"]; server: Server; stealthMode: Scalars["Boolean"]; tags?: Maybe<Maybe<GuildTag>[]> }

A single guild. Guilds earn their own rankings and contain characters. They may correspond to a guild in-game or be a custom guild created just to hold reports and rankings.

Type declaration

  • Optional __typename?: "Guild"
  • attendance: GuildAttendancePagination
  • competitionMode: Scalars["Boolean"]

    Whether or not the guild has competition mode enabled.

  • description: Scalars["String"]

    The description for the guild that is displayed with the guild name on the site.

  • faction: GameFaction

    The faction of the guild.

  • id: Scalars["Int"]

    The ID of the guild.

  • members: CharacterPagination

    The member roster for a specific guild. The result of this query is a paginated list of characters. This query only works for games where the guild roster is verifiable, e.g., it does not work for Classic Warcraft.

  • name: Scalars["String"]

    The name of the guild.

  • server: Server

    The server that the guild belongs to.

  • stealthMode: Scalars["Boolean"]

    Whether or not the guild has stealth mode enabled.

  • Optional tags?: Maybe<Maybe<GuildTag>[]>

    The tags used to label reports. In the site UI, these are called raid teams.

GuildAttendance

GuildAttendance: { __typename?: "GuildAttendance"; code: Scalars["String"]; players?: Maybe<Maybe<PlayerAttendance>[]>; startTime?: Maybe<Scalars["Float"]>; zone?: Maybe<Zone> }

Attendance for a specific report within a guild.

Type declaration

  • Optional __typename?: "GuildAttendance"
  • code: Scalars["String"]

    The code of the report for the raid night.

  • Optional players?: Maybe<Maybe<PlayerAttendance>[]>

    The players that attended that raid night.

  • Optional startTime?: Maybe<Scalars["Float"]>

    The start time of the raid night.

  • Optional zone?: Maybe<Zone>

    The principal zone of the raid night.

GuildAttendanceArgs

GuildAttendanceArgs: { guildTagID?: Maybe<Scalars["Int"]>; limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]>; zoneID?: Maybe<Scalars["Int"]> }

A single guild. Guilds earn their own rankings and contain characters. They may correspond to a guild in-game or be a custom guild created just to hold reports and rankings.

Type declaration

GuildAttendancePagination

GuildAttendancePagination: { __typename?: "GuildAttendancePagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<GuildAttendance>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GuildAttendancePagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<GuildAttendance>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GuildData

GuildData: { __typename?: "GuildData"; guild?: Maybe<Guild>; guilds?: Maybe<GuildPagination> }

The GuildData object enables the retrieval of single guilds or filtered collections of guilds.

Type declaration

  • Optional __typename?: "GuildData"
  • Optional guild?: Maybe<Guild>

    Obtain a specific guild either by id or by name/serverSlug/serverRegion.

  • Optional guilds?: Maybe<GuildPagination>

    The set of all guilds supported by the site. Can be optionally filtered to a specific server id.

GuildDataGuildArgs

GuildDataGuildArgs: { id?: Maybe<Scalars["Int"]>; name?: Maybe<Scalars["String"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]> }

The GuildData object enables the retrieval of single guilds or filtered collections of guilds.

Type declaration

GuildDataGuildsArgs

GuildDataGuildsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]>; serverID?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]> }

The GuildData object enables the retrieval of single guilds or filtered collections of guilds.

Type declaration

GuildMembersArgs

GuildMembersArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

A single guild. Guilds earn their own rankings and contain characters. They may correspond to a guild in-game or be a custom guild created just to hold reports and rankings.

Type declaration

GuildPagination

GuildPagination: { __typename?: "GuildPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<Guild>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "GuildPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<Guild>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

GuildTag

GuildTag: { __typename?: "GuildTag"; guild: Guild; id: Scalars["Int"]; name: Scalars["String"] }

The tag for a specific guild. Tags can be used to categorize reports within a guild. In the site UI, they are referred to as report tags.

Type declaration

  • Optional __typename?: "GuildTag"
  • guild: Guild

    The guild that the tag belongs to.

  • id: Scalars["Int"]

    The ID of the tag.

  • name: Scalars["String"]

    The name of the guild.

MakeMaybe

MakeMaybe<T, K>: Omit<T, K> & {[ SubKey in K]: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

MakeOptional

MakeOptional<T, K>: Omit<T, K> & {[ SubKey in K]: Maybe<T[SubKey]> }

Type parameters

  • T

  • K: keyof T

Maybe

Maybe<T>: T | null

Type parameters

  • T

Partition

Partition: { __typename?: "Partition"; compactName: Scalars["String"]; default: Scalars["Boolean"]; id: Scalars["Int"]; name: Scalars["String"] }

A single partition for a given raid zone. Partitions have an integer value representing the actual partition and a localized name that describes what the partition represents. Partitions contain their own rankings, statistics and all stars.

Type declaration

  • Optional __typename?: "Partition"
  • compactName: Scalars["String"]

    The compact localized name for the partition. Typically an abbreviation to conserve space.

  • default: Scalars["Boolean"]

    Whether or not the partition is the current default when viewing rankings or statistics for the zone.

  • id: Scalars["Int"]

    An integer representing a specific partition within a zone.

  • name: Scalars["String"]

    The localized name for partition.

PlayerAttendance

PlayerAttendance: { __typename?: "PlayerAttendance"; name?: Maybe<Scalars["String"]>; presence?: Maybe<Scalars["Int"]>; type?: Maybe<Scalars["String"]> }

Attendance for a specific player on a specific raid night.

Type declaration

  • Optional __typename?: "PlayerAttendance"
  • Optional name?: Maybe<Scalars["String"]>

    The name of the player.

  • Optional presence?: Maybe<Scalars["Int"]>

    Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.

  • Optional type?: Maybe<Scalars["String"]>

    The class of the player.

ProgressRaceData

ProgressRaceData: { __typename?: "ProgressRaceData"; progressRace?: Maybe<Scalars["JSON"]> }

A way to obtain data for the top guilds involved in an ongoing world first or realm first progress race.

Type declaration

  • Optional __typename?: "ProgressRaceData"
  • Optional progressRace?: Maybe<Scalars["JSON"]>

    Progress race information including best percentages, pull counts and streams for top guilds. This API is only active when there is an ongoing race. The format of this JSON may change without notice and is not considered frozen.

ProgressRaceDataProgressRaceArgs

ProgressRaceDataProgressRaceArgs: { difficulty?: Maybe<Scalars["Int"]>; serverRegion?: Maybe<Scalars["String"]>; serverSlug?: Maybe<Scalars["String"]>; serverSubregion?: Maybe<Scalars["String"]>; zoneID?: Maybe<Scalars["Int"]> }

A way to obtain data for the top guilds involved in an ongoing world first or realm first progress race.

Type declaration

Query

Query: { __typename?: "Query"; characterData?: Maybe<CharacterData>; gameData?: Maybe<GameData>; guildData?: Maybe<GuildData>; progressRaceData?: Maybe<ProgressRaceData>; rateLimitData?: Maybe<RateLimitData>; reportData?: Maybe<ReportData>; userData?: Maybe<UserData>; worldData?: Maybe<WorldData> }

Type declaration

  • Optional __typename?: "Query"
  • Optional characterData?: Maybe<CharacterData>

    Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.

  • Optional gameData?: Maybe<GameData>

    Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..

  • Optional guildData?: Maybe<GuildData>

    Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.

  • Optional progressRaceData?: Maybe<ProgressRaceData>

    Obtain information about an ongoing world first or realm first race. Inactive when no race is occurring. This data only updates once every 30 seconds, so you do not need to fetch this information more often than that.

  • Optional rateLimitData?: Maybe<RateLimitData>

    Obtain the rate limit data object to see how many points have been spent by this key.

  • Optional reportData?: Maybe<ReportData>

    Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.

  • Optional userData?: Maybe<UserData>

    Obtain the user object that allows the retrieval of the authorized user's id and username.

  • Optional worldData?: Maybe<WorldData>

    Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon/raid zones, and encounters.

RateLimitData

RateLimitData: { __typename?: "RateLimitData"; limitPerHour: Scalars["Int"]; pointsResetIn: Scalars["Int"]; pointsSpentThisHour: Scalars["Float"] }

A way to obtain your current rate limit usage.

Type declaration

  • Optional __typename?: "RateLimitData"
  • limitPerHour: Scalars["Int"]

    The total amount of points this API key can spend per hour.

  • pointsResetIn: Scalars["Int"]

    The number of seconds remaining until the points reset.

  • pointsSpentThisHour: Scalars["Float"]

    The total amount of points spent during this hour.

Region

Region: { __typename?: "Region"; compactName: Scalars["String"]; id: Scalars["Int"]; name: Scalars["String"]; servers?: Maybe<ServerPagination>; slug: Scalars["String"]; subregions?: Maybe<Maybe<Subregion>[]> }

A single region for the game.

Type declaration

  • Optional __typename?: "Region"
  • compactName: Scalars["String"]

    The localized compact name of the region, e.g., US for United States.

  • id: Scalars["Int"]

    The ID of the region.

  • name: Scalars["String"]

    The localized name of the region.

  • Optional servers?: Maybe<ServerPagination>

    The servers found within this region.

  • slug: Scalars["String"]

    The slug for the region, usable when looking up characters and guilds by server.

  • Optional subregions?: Maybe<Maybe<Subregion>[]>

    The subregions found within this region.

RegionServersArgs

RegionServersArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

A single region for the game.

Type declaration

Report

Report: { __typename?: "Report"; code: Scalars["String"]; endTime: Scalars["Float"]; events?: Maybe<ReportEventPaginator>; exportedSegments: Scalars["Int"]; fights?: Maybe<Maybe<ReportFight>[]>; graph?: Maybe<Scalars["JSON"]>; guild?: Maybe<Guild>; guildTag?: Maybe<GuildTag>; masterData?: Maybe<ReportMasterData>; owner?: Maybe<User>; playerDetails?: Maybe<Scalars["JSON"]>; rankedCharacters?: Maybe<Maybe<Character>[]>; rankings?: Maybe<Scalars["JSON"]>; region?: Maybe<Region>; revision: Scalars["Int"]; segments: Scalars["Int"]; startTime: Scalars["Float"]; table?: Maybe<Scalars["JSON"]>; title: Scalars["String"]; visibility: Scalars["String"]; zone?: Maybe<Zone> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

  • Optional __typename?: "Report"
  • code: Scalars["String"]

    The report code, a unique value used to identify the report.

  • endTime: Scalars["Float"]

    The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.

  • Optional events?: Maybe<ReportEventPaginator>

    A set of paginated report events, filterable via arguments like type, source, target, ability, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • exportedSegments: Scalars["Int"]

    The number of exported segments in the report. This is how many segments have been processed for rankings.

  • Optional fights?: Maybe<Maybe<ReportFight>[]>

    A set of fights with details about participating players.

  • Optional graph?: Maybe<Scalars["JSON"]>

    A graph of information for a report, filterable via arguments like type, source, target, ability, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • Optional guild?: Maybe<Guild>

    The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.

  • Optional guildTag?: Maybe<GuildTag>

    The guild tag that the report belongs to. If this is null, then the report was not tagged.

  • Optional masterData?: Maybe<ReportMasterData>

    Data from the report's master file. This includes version info, all of the players, NPCs and pets that occur in the report, and all the game abilities used in the report.

  • Optional owner?: Maybe<User>

    The user that uploaded the report.

  • Optional playerDetails?: Maybe<Scalars["JSON"]>

    A table of information for the players of a report, including their specs, talents, gear, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • Optional rankedCharacters?: Maybe<Maybe<Character>[]>

    A list of all characters that ranked on kills in the report.

  • Optional rankings?: Maybe<Scalars["JSON"]>

    Rankings information for a report, filterable to specific fights, bosses, metrics, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • Optional region?: Maybe<Region>

    The region of the report.

  • revision: Scalars["Int"]

    The revision of the report. This number is increased when reports get re-exported.

  • segments: Scalars["Int"]

    The number of uploaded segments in the report.

  • startTime: Scalars["Float"]

    The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.

  • Optional table?: Maybe<Scalars["JSON"]>

    A table of information for a report, filterable via arguments like type, source, target, ability, etc. This data is not considered frozen, and it can change without notice. Use at your own risk.

  • title: Scalars["String"]

    A title for the report.

  • visibility: Scalars["String"]

    The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.

  • Optional zone?: Maybe<Zone>

    The principal zone that the report contains fights for. Null if no supported zone exists.

ReportAbility

ReportAbility: { __typename?: "ReportAbility"; gameID?: Maybe<Scalars["Float"]>; icon?: Maybe<Scalars["String"]>; name?: Maybe<Scalars["String"]>; type?: Maybe<Scalars["String"]> }

The ReportAbility represents a single ability that occurs in the report.

Type declaration

  • Optional __typename?: "ReportAbility"
  • Optional gameID?: Maybe<Scalars["Float"]>

    The game ID of the ability.

  • Optional icon?: Maybe<Scalars["String"]>

    An icon to use for the ability.

  • Optional name?: Maybe<Scalars["String"]>

    The name of the actor.

  • Optional type?: Maybe<Scalars["String"]>

    The type of the ability. This represents the type of damage (e.g., the spell school in WoW).

ReportActor

ReportActor: { __typename?: "ReportActor"; gameID?: Maybe<Scalars["Float"]>; icon?: Maybe<Scalars["String"]>; id?: Maybe<Scalars["Int"]>; name?: Maybe<Scalars["String"]>; petOwner?: Maybe<Scalars["Int"]>; server?: Maybe<Scalars["String"]>; subType?: Maybe<Scalars["String"]>; type?: Maybe<Scalars["String"]> }

The ReportActor represents a single player, pet or NPC that occurs in the report.

Type declaration

  • Optional __typename?: "ReportActor"
  • Optional gameID?: Maybe<Scalars["Float"]>

    The game ID of the actor.

  • Optional icon?: Maybe<Scalars["String"]>

    An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.

  • Optional id?: Maybe<Scalars["Int"]>

    The report ID of the actor. This ID is used in events to identify sources and targets.

  • Optional name?: Maybe<Scalars["String"]>

    The name of the actor.

  • Optional petOwner?: Maybe<Scalars["Int"]>

    The report ID of the actor's owner if the actor is a pet.

  • Optional server?: Maybe<Scalars["String"]>

    The normalized server name of the actor.

  • Optional subType?: Maybe<Scalars["String"]>

    The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.

  • Optional type?: Maybe<Scalars["String"]>

    The type of the actor, i.e., if it is a player, pet or NPC.

ReportData

ReportData: { __typename?: "ReportData"; report?: Maybe<Report>; reports?: Maybe<ReportPagination> }

The ReportData object enables the retrieval of single reports or filtered collections of reports.

Type declaration

  • Optional __typename?: "ReportData"
  • Optional report?: Maybe<Report>

    Obtain a specific report by its code.

  • Optional reports?: Maybe<ReportPagination>

    A set of reports for a specific guild, guild tag, or user.

ReportDataReportArgs

ReportDataReportArgs: { code?: Maybe<Scalars["String"]> }

The ReportData object enables the retrieval of single reports or filtered collections of reports.

Type declaration

ReportDataReportsArgs

ReportDataReportsArgs: { endTime?: Maybe<Scalars["Float"]>; guildID?: Maybe<Scalars["Int"]>; guildName?: Maybe<Scalars["String"]>; guildServerRegion?: Maybe<Scalars["String"]>; guildServerSlug?: Maybe<Scalars["String"]>; guildTagID?: Maybe<Scalars["Int"]>; limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; userID?: Maybe<Scalars["Int"]>; zoneID?: Maybe<Scalars["Int"]> }

The ReportData object enables the retrieval of single reports or filtered collections of reports.

Type declaration

ReportDungeonPull

ReportDungeonPull: { __typename?: "ReportDungeonPull"; boundingBox?: Maybe<ReportMapBoundingBox>; encounterID: Scalars["Int"]; endTime: Scalars["Float"]; enemyNPCs?: Maybe<Maybe<ReportDungeonPullNpc>[]>; id: Scalars["Int"]; kill?: Maybe<Scalars["Boolean"]>; maps?: Maybe<Maybe<ReportMap>[]>; name: Scalars["String"]; startTime: Scalars["Float"]; x: Scalars["Int"]; y: Scalars["Int"] }

The ReportDungeonPull represents a single pull that occurs in a containing dungeon.

Type declaration

  • Optional __typename?: "ReportDungeonPull"
  • Optional boundingBox?: Maybe<ReportMapBoundingBox>

    The bounding box that encloses the positions of all players/enemies in the fight.

  • encounterID: Scalars["Int"]

    The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.

  • endTime: Scalars["Float"]

    The end time of the fight. This is a timestamp with millisecond precision that is relative to the start of the report, i.e., the start of the report is considered time 0.

  • Optional enemyNPCs?: Maybe<Maybe<ReportDungeonPullNpc>[]>

    Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.

  • id: Scalars["Int"]

    The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.

  • Optional kill?: Maybe<Scalars["Boolean"]>

    Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was an incomplete run, etc..

  • Optional maps?: Maybe<Maybe<ReportMap>[]>

    All the maps that were involved in a pull.

  • name: Scalars["String"]

    The name of the fight.

  • startTime: Scalars["Float"]

    The start time of the fight. This is a timestamp with millisecond precision that is relative to the start of the report, i.e., the start of the report is considered time 0.

  • x: Scalars["Int"]

    The x position of the first mob damaged in the pull at the time this damage happens. Used to establish a marker position to represent where the pull took place.

  • y: Scalars["Int"]

    The y position of the first mob damaged in the pull at the time this damage happens. Used to establish a marker position to represent where the pull took place.

ReportDungeonPullNpc

ReportDungeonPullNpc: { __typename?: "ReportDungeonPullNPC"; gameID?: Maybe<Scalars["Int"]>; id?: Maybe<Scalars["Int"]>; maximumInstanceGroupID?: Maybe<Scalars["Int"]>; maximumInstanceID?: Maybe<Scalars["Int"]>; minimumInstanceGroupID?: Maybe<Scalars["Int"]>; minimumInstanceID?: Maybe<Scalars["Int"]> }

The ReportDungeonPullNPC represents participation info within a single dungeon pull for an NPC.

Type declaration

  • Optional __typename?: "ReportDungeonPullNPC"
  • Optional gameID?: Maybe<Scalars["Int"]>

    The game ID of the actor, e.g., so it can be looked up on external Web sites.

  • Optional id?: Maybe<Scalars["Int"]>

    The report ID of the actor. This ID is used in events to identify sources and targets.

  • Optional maximumInstanceGroupID?: Maybe<Scalars["Int"]>

    The highest instance group ID seen during the pull.

  • Optional maximumInstanceID?: Maybe<Scalars["Int"]>

    The highest instance ID seen during the pull.

  • Optional minimumInstanceGroupID?: Maybe<Scalars["Int"]>

    The lowest instance group ID seen during the pull.

  • Optional minimumInstanceID?: Maybe<Scalars["Int"]>

    The lowest instance ID seen during the pull.

ReportEventPaginator

ReportEventPaginator: { __typename?: "ReportEventPaginator"; data?: Maybe<Scalars["JSON"]>; nextPageTimestamp?: Maybe<Scalars["Float"]> }

The ReportEventPaginator represents a paginated list of report events.

Type declaration

  • Optional __typename?: "ReportEventPaginator"
  • Optional data?: Maybe<Scalars["JSON"]>

    The list of events obtained.

  • Optional nextPageTimestamp?: Maybe<Scalars["Float"]>

    A timestamp to pass in as the start time when fetching the next page of data.

ReportEventsArgs

ReportEventsArgs: { abilityID?: Maybe<Scalars["Float"]>; dataType?: Maybe<EventDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; includeResources?: Maybe<Scalars["Boolean"]>; killType?: Maybe<KillType>; limit?: Maybe<Scalars["Int"]>; sourceClass?: Maybe<Scalars["String"]>; sourceID?: Maybe<Scalars["Int"]>; sourceInstanceID?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetID?: Maybe<Scalars["Int"]>; targetInstanceID?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; useAbilityIDs?: Maybe<Scalars["Boolean"]>; useActorIDs?: Maybe<Scalars["Boolean"]>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportFight

ReportFight: { __typename?: "ReportFight"; averageItemLevel?: Maybe<Scalars["Float"]>; bossPercentage?: Maybe<Scalars["Float"]>; boundingBox?: Maybe<ReportMapBoundingBox>; classicSeasonID?: Maybe<Scalars["Int"]>; completeRaid: Scalars["Boolean"]; difficulty?: Maybe<Scalars["Int"]>; dungeonPulls?: Maybe<Maybe<ReportDungeonPull>[]>; encounterID: Scalars["Int"]; endTime: Scalars["Float"]; enemyNPCs?: Maybe<Maybe<ReportFightNpc>[]>; enemyPets?: Maybe<Maybe<ReportFightNpc>[]>; enemyPlayers?: Maybe<Maybe<Scalars["Int"]>[]>; fightPercentage?: Maybe<Scalars["Float"]>; friendlyNPCs?: Maybe<Maybe<ReportFightNpc>[]>; friendlyPets?: Maybe<Maybe<ReportFightNpc>[]>; friendlyPlayers?: Maybe<Maybe<Scalars["Int"]>[]>; gameZone?: Maybe<GameZone>; id: Scalars["Int"]; keystoneAffixes?: Maybe<Maybe<Scalars["Int"]>[]>; keystoneBonus?: Maybe<Scalars["Int"]>; keystoneLevel?: Maybe<Scalars["Int"]>; keystoneTime?: Maybe<Scalars["Int"]>; kill?: Maybe<Scalars["Boolean"]>; lastPhase?: Maybe<Scalars["Int"]>; lastPhaseIsIntermission?: Maybe<Scalars["Boolean"]>; layer?: Maybe<Scalars["Int"]>; maps?: Maybe<Maybe<ReportMap>[]>; name: Scalars["String"]; rating?: Maybe<Scalars["Int"]>; size?: Maybe<Scalars["Int"]>; startTime: Scalars["Float"]; wipeCalledTime?: Maybe<Scalars["Float"]> }

The ReportFight represents a single fight that occurs in the report.

Type declaration

  • Optional __typename?: "ReportFight"
  • Optional averageItemLevel?: Maybe<Scalars["Float"]>

    The average item level of the players in the fight.

  • Optional bossPercentage?: Maybe<Scalars["Float"]>

    The percentage health of the active boss or bosses at the end of a fight.

  • Optional boundingBox?: Maybe<ReportMapBoundingBox>

    The bounding box that encloses the positions of all players/enemies in the fight.

  • Optional classicSeasonID?: Maybe<Scalars["Int"]>

    The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.

  • completeRaid: Scalars["Boolean"]

    Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.

  • Optional difficulty?: Maybe<Scalars["Int"]>

    The difficulty setting for the raid, dungeon, or arena. Null for trash.

  • Optional dungeonPulls?: Maybe<Maybe<ReportDungeonPull>[]>

    For a dungeon, a list of pulls that occurred in the dungeon. Pulls have details such as the enemies involved in the pull and map info showing where the pull took place.

  • encounterID: Scalars["Int"]

    The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.

  • endTime: Scalars["Float"]

    The end time of the fight. This is a timestamp with millisecond precision that is relative to the start of the report, i.e., the start of the report is considered time 0.

  • Optional enemyNPCs?: Maybe<Maybe<ReportFightNpc>[]>

    Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.

  • Optional enemyPets?: Maybe<Maybe<ReportFightNpc>[]>

    Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.

  • Optional enemyPlayers?: Maybe<Maybe<Scalars["Int"]>[]>

    The IDs of all players involved in a fight. These players can be referenced in the master data actors table to get detailed information about each participant.

  • Optional fightPercentage?: Maybe<Scalars["Float"]>

    The actual completion percentage of the fight. This is the field used to indicate how far into a fight a wipe was, since fights can be complicated and have multiple bosses, no bosses, bosses that heal, etc.

  • Optional friendlyNPCs?: Maybe<Maybe<ReportFightNpc>[]>

    Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.

  • Optional friendlyPets?: Maybe<Maybe<ReportFightNpc>[]>

    Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.

  • Optional friendlyPlayers?: Maybe<Maybe<Scalars["Int"]>[]>

    The IDs of all players involved in a fight. These players can be referenced in the master data actors table to get detailed information about each participant.

  • Optional gameZone?: Maybe<GameZone>

    The game zone the fight takes place in. This should not be confused with the zones used by the sites for rankings. This is the actual in-game zone info.

  • id: Scalars["Int"]

    The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.

  • Optional keystoneAffixes?: Maybe<Maybe<Scalars["Int"]>[]>

    The affixes for a Mythic+ dungeon.

  • Optional keystoneBonus?: Maybe<Scalars["Int"]>

    The bonus field represents Bronze, Silver or Gold in Challenge Modes, or +1-+3 pushing of Mythic+ keys. It has the values 1, 2, and 3.

  • Optional keystoneLevel?: Maybe<Scalars["Int"]>

    The keystone level for a Mythic+ dungeon.

  • Optional keystoneTime?: Maybe<Scalars["Int"]>

    The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.

  • Optional kill?: Maybe<Scalars["Boolean"]>

    Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was an incomplete run, etc..

  • Optional lastPhase?: Maybe<Scalars["Int"]>

    The phase that the encounter was in when the fight ended.

  • Optional lastPhaseIsIntermission?: Maybe<Scalars["Boolean"]>

    Whether or not the phase that the encounter was in when the fight ended was an intermission or not.

  • Optional layer?: Maybe<Scalars["Int"]>

    The layer of a Torghast run.

  • Optional maps?: Maybe<Maybe<ReportMap>[]>

    All the maps that were involved in a fight. For single bosses this will usually be a single map, but for dungeons it will typically be multiple maps.

  • name: Scalars["String"]

    The name of the fight.

  • Optional rating?: Maybe<Scalars["Int"]>

    The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.

  • Optional size?: Maybe<Scalars["Int"]>

    The group size for the raid, dungeon, or arena. Null for trash.

  • startTime: Scalars["Float"]

    The start time of the fight. This is a timestamp with millisecond precision that is relative to the start of the report, i.e., the start of the report is considered time 0.

  • Optional wipeCalledTime?: Maybe<Scalars["Float"]>

    If a wipe was explicitly called using the Companion app, then this field will contain the time. This is a timestamp with millisecond precision that is relative to the start of the report, i.e., the start of the report is considered time 0.

ReportFightNpc

ReportFightNpc: { __typename?: "ReportFightNPC"; gameID?: Maybe<Scalars["Int"]>; groupCount?: Maybe<Scalars["Int"]>; id?: Maybe<Scalars["Int"]>; instanceCount?: Maybe<Scalars["Int"]>; petOwner?: Maybe<Scalars["Int"]> }

The ReportFightNPC represents participation info within a single fight for an NPC.

Type declaration

  • Optional __typename?: "ReportFightNPC"
  • Optional gameID?: Maybe<Scalars["Int"]>

    The game ID of the actor. This ID is used in events to identify sources and targets.

  • Optional groupCount?: Maybe<Scalars["Int"]>

    How many packs of the NPC were seen during the fight.

  • Optional id?: Maybe<Scalars["Int"]>

    The report ID of the actor. This ID is used in events to identify sources and targets.

  • Optional instanceCount?: Maybe<Scalars["Int"]>

    How many instances of the NPC were seen during the fight.

  • Optional petOwner?: Maybe<Scalars["Int"]>

    The report ID of the actor that owns this NPC (if it is a pet). This ID is used in events to identify sources and targets.

ReportFightsArgs

ReportFightsArgs: { difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; killType?: Maybe<KillType>; translate?: Maybe<Scalars["Boolean"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportGraphArgs

ReportGraphArgs: { abilityID?: Maybe<Scalars["Float"]>; dataType?: Maybe<GraphDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; killType?: Maybe<KillType>; sourceClass?: Maybe<Scalars["String"]>; sourceID?: Maybe<Scalars["Int"]>; sourceInstanceID?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetID?: Maybe<Scalars["Int"]>; targetInstanceID?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; viewBy?: Maybe<ViewType>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportMap

ReportMap: { __typename?: "ReportMap"; id: Scalars["Int"] }

The ReportMap represents a single map that a fight can occur on.

Type declaration

  • Optional __typename?: "ReportMap"
  • id: Scalars["Int"]

    The map's game ID.

ReportMapBoundingBox

ReportMapBoundingBox: { __typename?: "ReportMapBoundingBox"; maxX: Scalars["Int"]; maxY: Scalars["Int"]; minX: Scalars["Int"]; minY: Scalars["Int"] }

The ReportMapBoundingBox is a box that encloses the positions of all players and enemies in a fight or dungeon pull.

Type declaration

  • Optional __typename?: "ReportMapBoundingBox"
  • maxX: Scalars["Int"]

    The largest X position.

  • maxY: Scalars["Int"]

    The largest Y position.

  • minX: Scalars["Int"]

    The smallest X position.

  • minY: Scalars["Int"]

    The smallest Y position.

ReportMasterData

ReportMasterData: { __typename?: "ReportMasterData"; abilities?: Maybe<Maybe<ReportAbility>[]>; actors?: Maybe<Maybe<ReportActor>[]>; gameVersion?: Maybe<Scalars["Int"]>; lang?: Maybe<Scalars["String"]>; logVersion: Scalars["Int"] }

The ReporMastertData object contains information about the log version of a report, as well as the actors and abilities used in the report.

Type declaration

  • Optional __typename?: "ReportMasterData"
  • Optional abilities?: Maybe<Maybe<ReportAbility>[]>

    A list of every ability that occurs in the report.

  • Optional actors?: Maybe<Maybe<ReportActor>[]>

    A list of every actor (player, NPC, pet) that occurs in the report.

  • Optional gameVersion?: Maybe<Scalars["Int"]>

    The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.

  • Optional lang?: Maybe<Scalars["String"]>

    The auto-detected locale of the report. This is the source language of the original log file.

  • logVersion: Scalars["Int"]

    The version of the client parser that was used to parse and upload this log file.

ReportMasterDataActorsArgs

ReportMasterDataActorsArgs: { subType?: Maybe<Scalars["String"]>; type?: Maybe<Scalars["String"]> }

The ReporMastertData object contains information about the log version of a report, as well as the actors and abilities used in the report.

Type declaration

ReportMasterDataArgs

ReportMasterDataArgs: { translate?: Maybe<Scalars["Boolean"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportPagination

ReportPagination: { __typename?: "ReportPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<Report>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "ReportPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<Report>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

ReportPlayerDetailsArgs

ReportPlayerDetailsArgs: { difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; killType?: Maybe<KillType>; startTime?: Maybe<Scalars["Float"]>; translate?: Maybe<Scalars["Boolean"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportRankingsArgs

ReportRankingsArgs: { compare?: Maybe<RankingCompareType>; difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; playerMetric?: Maybe<ReportRankingMetricType>; timeframe?: Maybe<RankingTimeframeType> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

ReportTableArgs

ReportTableArgs: { abilityID?: Maybe<Scalars["Float"]>; dataType?: Maybe<TableDataType>; death?: Maybe<Scalars["Int"]>; difficulty?: Maybe<Scalars["Int"]>; encounterID?: Maybe<Scalars["Int"]>; endTime?: Maybe<Scalars["Float"]>; fightIDs?: Maybe<Maybe<Scalars["Int"]>[]>; filterExpression?: Maybe<Scalars["String"]>; hostilityType?: Maybe<HostilityType>; killType?: Maybe<KillType>; sourceClass?: Maybe<Scalars["String"]>; sourceID?: Maybe<Scalars["Int"]>; sourceInstanceID?: Maybe<Scalars["Int"]>; startTime?: Maybe<Scalars["Float"]>; targetClass?: Maybe<Scalars["String"]>; targetID?: Maybe<Scalars["Int"]>; targetInstanceID?: Maybe<Scalars["Int"]>; translate?: Maybe<Scalars["Boolean"]>; viewBy?: Maybe<ViewType>; viewOptions?: Maybe<Scalars["Int"]>; wipeCutoff?: Maybe<Scalars["Int"]> }

A single report uploaded by a player to a guild or personal logs.

Type declaration

Scalars

Scalars: { Boolean: boolean; Float: number; ID: string; Int: number; JSON: any; String: string }

All built-in and custom scalars, mapped to their actual values

Type declaration

  • Boolean: boolean
  • Float: number
  • ID: string
  • Int: number
  • JSON: any
  • String: string

Sdk

Sdk: ReturnType<typeof getSdk>

SdkFunctionWrapper

SdkFunctionWrapper: <T>(action: () => Promise<T>) => Promise<T>

Type declaration

    • <T>(action: () => Promise<T>): Promise<T>
    • Type parameters

      • T

      Parameters

      • action: () => Promise<T>
          • (): Promise<T>
          • Returns Promise<T>

      Returns Promise<T>

Server

Server: { __typename?: "Server"; guilds?: Maybe<GuildPagination>; id: Scalars["Int"]; name: Scalars["String"]; normalizedName: Scalars["String"]; region: Region; slug: Scalars["String"]; subregion: Subregion }

A single server. Servers correspond to actual game servers that characters and guilds reside on.

Type declaration

  • Optional __typename?: "Server"
  • Optional guilds?: Maybe<GuildPagination>

    The guilds found on this server (and any servers connected to this one.

  • id: Scalars["Int"]

    The ID of the server.

  • name: Scalars["String"]

    The name of the server in the locale of the subregion that the server belongs to.

  • normalizedName: Scalars["String"]

    The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.

  • region: Region

    The region that this server belongs to.

  • slug: Scalars["String"]

    The server slug, also a transformation of the name following Blizzard rules. For retail World of Warcraft realms, this slug will be in English. For all other games, the slug is just a transformation of the name field.

  • subregion: Subregion

    The subregion that this server belongs to.

ServerGuildsArgs

ServerGuildsArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

A single server. Servers correspond to actual game servers that characters and guilds reside on.

Type declaration

ServerPagination

ServerPagination: { __typename?: "ServerPagination"; current_page: Scalars["Int"]; data?: Maybe<Maybe<Server>[]>; from?: Maybe<Scalars["Int"]>; has_more_pages: Scalars["Boolean"]; last_page: Scalars["Int"]; per_page: Scalars["Int"]; to?: Maybe<Scalars["Int"]>; total: Scalars["Int"] }

Type declaration

  • Optional __typename?: "ServerPagination"
  • current_page: Scalars["Int"]

    Current page of the cursor

  • Optional data?: Maybe<Maybe<Server>[]>

    List of items on the current page

  • Optional from?: Maybe<Scalars["Int"]>

    Number of the first item returned

  • has_more_pages: Scalars["Boolean"]

    Determines if cursor has more pages after the current page

  • last_page: Scalars["Int"]

    The last page (number of pages)

  • per_page: Scalars["Int"]

    Number of items returned per page

  • Optional to?: Maybe<Scalars["Int"]>

    Number of the last item returned

  • total: Scalars["Int"]

    Number of total items selected by the query

Spec

Spec: { __typename?: "Spec"; class: GameClass; id: Scalars["Int"]; name: Scalars["String"]; slug: Scalars["String"] }

A spec for a given player class.

Type declaration

  • Optional __typename?: "Spec"
  • class: GameClass

    The player class that the spec belongs to.

  • id: Scalars["Int"]

    An integer used to identify the spec.

  • name: Scalars["String"]

    The localized name of the class.

  • slug: Scalars["String"]

    A slug used to identify the spec.

Subregion

Subregion: { __typename?: "Subregion"; id: Scalars["Int"]; name: Scalars["String"]; region: Region; servers?: Maybe<ServerPagination> }

A single subregion. Subregions are used to divide a region into sub-categories, such as French or German subregions of a Europe region.

Type declaration

  • Optional __typename?: "Subregion"
  • id: Scalars["Int"]

    The ID of the subregion.

  • name: Scalars["String"]

    The localized name of the subregion.

  • region: Region

    The region that this subregion is found in.

  • Optional servers?: Maybe<ServerPagination>

    The servers found within this region.

SubregionServersArgs

SubregionServersArgs: { limit?: Maybe<Scalars["Int"]>; page?: Maybe<Scalars["Int"]> }

A single subregion. Subregions are used to divide a region into sub-categories, such as French or German subregions of a Europe region.

Type declaration

User

User: { __typename?: "User"; battleTag?: Maybe<Scalars["String"]>; id: Scalars["Int"]; name: Scalars["String"] }

A single user of the site.

Type declaration

  • Optional __typename?: "User"
  • Optional battleTag?: Maybe<Scalars["String"]>

    The battle tag of the user if they have linked it.

  • id: Scalars["Int"]

    The ID of the user.

  • name: Scalars["String"]

    The name of the user.

UserData

UserData: { __typename?: "UserData"; currentUser?: Maybe<User>; user?: Maybe<User> }

The user data object contains basic information about users and lets you retrieve specific users (or the current user if using the user endpoint).

Type declaration

  • Optional __typename?: "UserData"
  • Optional currentUser?: Maybe<User>

    Obtain the current user (only works with user endpoint).

  • Optional user?: Maybe<User>

    Obtain a specific user by id.

UserDataUserArgs

UserDataUserArgs: { id?: Maybe<Scalars["Int"]> }

The user data object contains basic information about users and lets you retrieve specific users (or the current user if using the user endpoint).

Type declaration

ViewModels

ViewModels: { __typename?: "ViewModels"; article?: Maybe<Scalars["JSON"]>; articleCategories?: Maybe<Scalars["JSON"]>; articleSlugs?: Maybe<Scalars["JSON"]>; game?: Maybe<Scalars["JSON"]>; googleAnalytics?: Maybe<Scalars["JSON"]>; headerTitle?: Maybe<Scalars["JSON"]> }

Type declaration

ViewModelsArticleArgs

ViewModelsArticleArgs: { articleCategorySlug?: Maybe<Scalars["String"]>; articleSlug?: Maybe<Scalars["String"]>; siteName?: Maybe<Scalars["String"]> }

Type declaration

ViewModelsArticleSlugsArgs

ViewModelsArticleSlugsArgs: { articleCategorySlug?: Maybe<Scalars["String"]>; siteName?: Maybe<Scalars["String"]> }

Type declaration

WorldData

WorldData: { __typename?: "WorldData"; encounter?: Maybe<Encounter>; expansion?: Maybe<Expansion>; expansions?: Maybe<Maybe<Expansion>[]>; region?: Maybe<Region>; regions?: Maybe<Maybe<Region>[]>; server?: Maybe<Server>; subregion?: Maybe<Subregion>; zone?: Maybe<Zone>; zones?: Maybe<Maybe<Zone>[]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

  • Optional __typename?: "WorldData"
  • Optional encounter?: Maybe<Encounter>

    Obtain a specific encounter by id.

  • Optional expansion?: Maybe<Expansion>

    A single expansion obtained by ID.

  • Optional expansions?: Maybe<Maybe<Expansion>[]>

    The set of all expansions supported by the site.

  • Optional region?: Maybe<Region>

    Obtain a specific region by its ID.

  • Optional regions?: Maybe<Maybe<Region>[]>

    The set of all regions supported by the site.

  • Optional server?: Maybe<Server>

    Obtain a specific server either by id or by slug and region.

  • Optional subregion?: Maybe<Subregion>

    Obtain a specific subregion by its ID.

  • Optional zone?: Maybe<Zone>

    Obtain a specific zone by its ID.

  • Optional zones?: Maybe<Maybe<Zone>[]>

    Obtain a set of all zones supported by the site.

WorldDataEncounterArgs

WorldDataEncounterArgs: { id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataExpansionArgs

WorldDataExpansionArgs: { id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataRegionArgs

WorldDataRegionArgs: { id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataServerArgs

WorldDataServerArgs: { id?: Maybe<Scalars["Int"]>; region?: Maybe<Scalars["String"]>; slug?: Maybe<Scalars["String"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataSubregionArgs

WorldDataSubregionArgs: { id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataZoneArgs

WorldDataZoneArgs: { id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

WorldDataZonesArgs

WorldDataZonesArgs: { expansion_id?: Maybe<Scalars["Int"]> }

The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.

Type declaration

Zone

Zone: { __typename?: "Zone"; brackets?: Maybe<Bracket>; difficulties?: Maybe<Maybe<Difficulty>[]>; encounters?: Maybe<Maybe<Encounter>[]>; expansion: Expansion; frozen: Scalars["Boolean"]; id: Scalars["Int"]; name: Scalars["String"]; partitions?: Maybe<Maybe<Partition>[]> }

A single zone from an expansion that represents a raid, dungeon, arena, etc.

Type declaration

  • Optional __typename?: "Zone"
  • Optional brackets?: Maybe<Bracket>

    The bracket information for this zone. This field will be null if the zone does not support brackets.

  • Optional difficulties?: Maybe<Maybe<Difficulty>[]>

    A list of all the difficulties supported for this zone.

  • Optional encounters?: Maybe<Maybe<Encounter>[]>

    The encounters found within this zone.

  • expansion: Expansion

    The expansion that this zone belongs to.

  • frozen: Scalars["Boolean"]

    Whether or not the entire zone (including all its partitions) is permanently frozen. When a zone is frozen, data involving that zone will never change and can be cached forever.

  • id: Scalars["Int"]

    The ID of the zone.

  • name: Scalars["String"]

    The name of the zone.

  • Optional partitions?: Maybe<Maybe<Partition>[]>

    A list of all the partitions supported for this zone.

Variables

Const GetAbilityDocument

GetAbilityDocument: DocumentNode = ...

Const GetAchievementDocument

GetAchievementDocument: DocumentNode = ...

Const GetAffixesDocument

GetAffixesDocument: DocumentNode = ...

Const GetCharacterDocument

GetCharacterDocument: DocumentNode = ...

Const GetCharacterEncounterRankingsDocument

GetCharacterEncounterRankingsDocument: DocumentNode = ...

Const GetCharacterZoneRankingsDocument

GetCharacterZoneRankingsDocument: DocumentNode = ...

Const GetClassesDocument

GetClassesDocument: DocumentNode = ...

Const GetEnchantDocument

GetEnchantDocument: DocumentNode = ...

Const GetEncounterCharacterRankingsDocument

GetEncounterCharacterRankingsDocument: DocumentNode = ...

Const GetEncounterFightRankingsDocument

GetEncounterFightRankingsDocument: DocumentNode = ...

Const GetFactionsDocument

GetFactionsDocument: DocumentNode = ...

Const GetGuildDocument

GetGuildDocument: DocumentNode = ...

Const GetGuildReportsDocument

GetGuildReportsDocument: DocumentNode = ...

Const GetItemDocument

GetItemDocument: DocumentNode = ...

Const GetNpcDocument

GetNpcDocument: DocumentNode = ...

Const GetProgressRaceDocument

GetProgressRaceDocument: DocumentNode = ...

Const GetRateLimitDocument

GetRateLimitDocument: DocumentNode = ...

Const GetReportEventsDocument

GetReportEventsDocument: DocumentNode = ...

Const GetReportFightsDocument

GetReportFightsDocument: DocumentNode = ...

Const GetReportGraphDocument

GetReportGraphDocument: DocumentNode = ...

Const GetReportPlayerDetailsDocument

GetReportPlayerDetailsDocument: DocumentNode = ...

Const GetReportRankedCharactersDocument

GetReportRankedCharactersDocument: DocumentNode = ...

Const GetReportTableDocument

GetReportTableDocument: DocumentNode = ...

Const GetUserReportsDocument

GetUserReportsDocument: DocumentNode = ...

Const GetZonesDocument

GetZonesDocument: DocumentNode = ...

Functions

Const buildSdk

  • buildSdk(accessToken: string, game?: string): { getAbility: any; getAchievement: any; getAffixes: any; getCharacter: any; getCharacterEncounterRankings: any; getCharacterZoneRankings: any; getClasses: any; getEnchant: any; getEncounterCharacterRankings: any; getEncounterFightRankings: any; getFactions: any; getGuild: any; getGuildReports: any; getItem: any; getNpc: any; getProgressRace: any; getRateLimit: any; getReportEvents: any; getReportFights: any; getReportGraph: any; getReportPlayerDetails: any; getReportRankedCharacters: any; getReportTable: any; getUserReports: any; getZones: any }

getSdk

  • getSdk(client: GraphQLClient, withWrapper?: SdkFunctionWrapper): { getAbility: any; getAchievement: any; getAffixes: any; getCharacter: any; getCharacterEncounterRankings: any; getCharacterZoneRankings: any; getClasses: any; getEnchant: any; getEncounterCharacterRankings: any; getEncounterFightRankings: any; getFactions: any; getGuild: any; getGuildReports: any; getItem: any; getNpc: any; getProgressRace: any; getRateLimit: any; getReportEvents: any; getReportFights: any; getReportGraph: any; getReportPlayerDetails: any; getReportRankedCharacters: any; getReportTable: any; getUserReports: any; getZones: any }

Generated using TypeDoc