From 00f18dadbca62b9d2237d5a0c554e94b007da003 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Mon, 15 Jan 2024 02:23:11 -0700 Subject: [PATCH 1/7] begin reworking query subsystem --- main.py | 158 + wcl/caching.py | 12 +- wcl/interface.py | 15 +- wcl/introspection_query.json | 99 + wcl/{token.py => oauth_token.py} | 4 +- wcl/query.py | 416 +- wcl/query_generated.py | 89 + wcl/{requests.py => request.py} | 11 +- wcl/schema.json | 11780 +++++++++++++++++++++++++++++ 9 files changed, 12536 insertions(+), 48 deletions(-) create mode 100644 wcl/introspection_query.json rename wcl/{token.py => oauth_token.py} (98%) create mode 100644 wcl/query_generated.py rename wcl/{requests.py => request.py} (92%) create mode 100644 wcl/schema.json diff --git a/main.py b/main.py index 6747960..a277dd6 100644 --- a/main.py +++ b/main.py @@ -153,3 +153,161 @@ # ['Learning', 'Eyebrowz', 'Glimmerer', 'Tacofajita', 'Hunkytwunky', 'Bobblywobbly'] # ] # ) + +import wcl + +# t = wcl.GQL_Object( {'asdf': 'fdsa'}, {'jkl': 'lkj'} ) +# print(t) + +# class Test: +# asdf = 'jkl' + +# d = { +# '1': Test +# } + +# for v in d.values(): +# print(isinstance(Test(), v)) + +# u = wcl.GQL_Test1( {}, {} ).tree() +# v = wcl.GQL_Test2( {}, {} ).tree() +# print(u) +# print(v) +class GQL_OBJECT: + active = [] + name = 'GQL_OBJECT' + def __init__( self, child_class_name = '', child_str = '' ): + self.child_class_name = child_class_name + self.child_str = child_str + + self.parent = self.__class__.__mro__[1] + self.children = list(self.__class__.__subclasses__()) + + def __str__( self ): + children = [ + self.child_str if child.name == self.child_class_name else str( child.name ) + for child in self.children + if child.name in self.active + ] + ret = self.name + if len( children ): + ret += '{' + ', '.join( children ) + '}' + if self.parent.__name__ != 'GQL_OBJECT': + return str( self.parent( self.name, ret ) ) + return '{' + ret + '}' + +class query( GQL_OBJECT ): + name = 'query' + active = [ 'report' ] + report = lambda *args, **kwargs: eval( '_QrsNKiY_WLpJ6Iu_report' )( *args, **kwargs ) + +class _QrsNKiY_WLpJ6Iu_report( query, GQL_OBJECT ): + name = 'report' + active = [ 'code', 'events' ] + code = lambda *args, **kwargs: eval( '_MqAkvZzWS6CGIGj_code' )( *args, **kwargs ) + events = lambda *args, **kwargs: eval( '_GZ3efcSVmPvraRn_events' )( *args, **kwargs ) + +class _MqAkvZzWS6CGIGj_code( _QrsNKiY_WLpJ6Iu_report, GQL_OBJECT ): + name = 'code' + +class _GZ3efcSVmPvraRn_events( _QrsNKiY_WLpJ6Iu_report, GQL_OBJECT ): + name = 'events' + +print( query().report().events() ) + +import unicodedata +from keyword import iskeyword +import random +import sys + +def is_allowed_unicode_char( c, position ): + # Other_ID_Start and Other_ID_Continue are from the following webpage with the matching category (?) name + # https://www.unicode.org/Public/15.0.0/ucd/PropList.txt + Other_ID_Start = { '\u1885', '\u1886', '\u2118', '\u212E', '\u309B', '\u309C' } + Other_ID_Continue = { '\u00B7', '\u0387', '\u1369', '\u1370', '\u1371', '\u19DA' } + # id_start and id_continue category_codes are defined from the following webpage: + # https://docs.python.org/3/reference/lexical_analysis.html#identifiers + id_start_category_codes = { 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' } + id_continue_category_codes = id_start_category_codes | { 'Mn', 'Mc', 'Nd', 'Pc' } + # id_start and id_continue singletons are defined from the following webpage: + # https://docs.python.org/3/reference/lexical_analysis.html#identifiers + id_start_singletons = { '_' } | Other_ID_Start + id_continue_singletons = id_start_singletons | Other_ID_Continue + + if unicodedata.category( c ) in id_start_category_codes or c in id_start_singletons: + return c + if position > 0 and ( unicodedata.category( c ) in id_continue_category_codes or c in id_continue_singletons ): + return c + +def generate_unicode_identifier( length = 16 ): + # This implementation is correct, but returned strings are: + # - Unmanageably unreadable + # - Not reliably generated due to too small of a character set (to improve readability) + # - Requires too much pregeneration (to avoid unreliable generation) + + # This does not generate all possible unicode identifiers, as I did not find + # a way to find all characters that NFKC normalize to a valid character. + def generate_chr(attempt = 0): + c = chr( random.randrange( sys.maxunicode + 1 ) ) + if is_allowed_unicode_char( c, 0 ): + return c + return generate_chr( attempt + 1 ) + + candidate_str = ''.join( [ + c + for _ in range( length ) + if ( c := generate_chr() ) + ] ) + + if not iskeyword( candidate_str ): + return candidate_str + return generate_unicode_identifier( length = length ) + +def generate_ascii_identifier( length = 16 ): + # Only a small subset of valid Python 3 Identifiers, but: + # - Highly readable + # - Still millions of combinations + # - More trivial to generate + MIN_ASCII = 33 + MAX_ASCII = 126 + + def generate_chr( position, attempts = 0 ): + character = chr( random.randrange( MIN_ASCII, MAX_ASCII ) ) + if is_allowed_unicode_char( character, position ): + return character + return generate_chr( position, attempts + 1) + + candidate_str = '_' + ''.join( [ + generate_chr( pos ) + for pos in range( length - 1 ) + ] ) + + if not iskeyword( candidate_str ) and candidate_str.isidentifier(): + return candidate_str + return generate_ascii_identifier( length = length ) + + +# for k in range( 5 ): +# ident = generate_ascii_identifier() +# print(ident, len(ident)) + + + +# PROBLEM: +# - nested classes are gross +# - having no nested classes with their actual names results in namespace clashes +# SOLUTION: +# a) +# - queries with no parents get their actual name for their object name +# - queries with parents get an internal name, and are added to the parent with their real name via `__subclasses__()` and `setattr(...)` +# b) +# - infrastructure exists for type hoisting, but it may not be useful in this situation + +# print(C()) +# print(C().D()) + +# print( A() ) +# for q in A().children: +# print( q(), q().parent() ) +# for u in q().children: +# print( u(), u().parent() ) diff --git a/wcl/caching.py b/wcl/caching.py index 0dd9521..e54c468 100644 --- a/wcl/caching.py +++ b/wcl/caching.py @@ -1,6 +1,4 @@ -import json -import os -import uuid +import json, os, uuid # Caches queries by identifier in a lookup table in `repo root/cache`. # As implemented in requests, identifier is completed query that has been @@ -11,12 +9,14 @@ def decorator( query ): ret = None cache = Cache() + query_str = str( query ) + if query.cacheable: - ret = Request( query, cache.get_artifact( query.string ) ) + ret = Request( query, cache.get_artifact( query_str ) ) if ret is None: ret = Request( query ) - if query.cacheable and not cache.lookup_uuid( query.string ): - cache.put_artifact( query.string, ret.data ) + if query.cacheable and not cache.lookup_uuid( query_str ): + cache.put_artifact( query_str, ret.data ) return ret return decorator diff --git a/wcl/interface.py b/wcl/interface.py index 3b66532..d790e8d 100644 --- a/wcl/interface.py +++ b/wcl/interface.py @@ -3,27 +3,26 @@ from numpy import char -from . import query -from .requests import Request +from . import query, request def getFights( params ): - return Request( query.Fights( params ) ).data + return request.Request( query.Fights( params ) ).data def getPlayerDetails( params ): - return Request( query.PlayerDetails( params ) ).data.get( 'data', {} ).get( 'playerDetails', {} ) or {} # pyright: ignore + return request.Request( query.PlayerDetails( params ) ).data.get( 'data', {} ).get( 'playerDetails', {} ) or {} # pyright: ignore def getMasterData( params ): - return Request( query.Actors( params ) ).data + return request.Request( query.Actors( params ) ).data def getEvents( params ): - return Request( query.Events( params ) ).data.get( 'data', {} ) + return Request( query.Events( params ) ).data.get( 'data', {} ) or {} # pyright: ignore def getCombatantInfo( params ): params_copy = deepcopy( params ) params_copy.update( { 'filterExpression': "type in ('combatantinfo')" } ) - return Request( query.Events( params_copy ) ).data.get( 'data', [] ) + return request.Request( query.Events( params_copy ) ).data.get( 'data', [] ) def printFights( params ): req = getFights( params ) @@ -58,7 +57,7 @@ def printPlayerDetails( params ): def getPointsSpent(): params = {} - req = Request( query.PointsSpentThisHour( params ) ).data.get( 'pointsSpentThisHour' ) + req = request.Request( query.PointsSpentThisHour( params ) ).data.get( 'pointsSpentThisHour' ) return print( req, 'point' if req == 1 else 'points', 'spent this hour' ) # pyright: ignore def getPlayerFromID( id, params ): diff --git a/wcl/introspection_query.json b/wcl/introspection_query.json new file mode 100644 index 0000000..d17da75 --- /dev/null +++ b/wcl/introspection_query.json @@ -0,0 +1,99 @@ +query IntrospectionQuery { + __schema { + queryType { + name + } + mutationType { + name + } + subscriptionType { + name + } + types { + ...FullType + } + directives { + name + description + locations + args { + ...InputValue + } + } + } +} + +fragment FullType on __Type { + kind + name + description + fields(includeDeprecated: true) { + name + description + args { + ...InputValue + } + type { + ...TypeRef + } + isDeprecated + deprecationReason + } + inputFields { + ...InputValue + } + interfaces { + ...TypeRef + } + enumValues(includeDeprecated: true) { + name + description + isDeprecated + deprecationReason + } + possibleTypes { + ...TypeRef + } +} + +fragment InputValue on __InputValue { + name + description + type { + ...TypeRef + } + defaultValue +} + +fragment TypeRef on __Type { + kind + name + ofType { + kind + name + ofType { + kind + name + ofType { + kind + name + ofType { + kind + name + ofType { + kind + name + ofType { + kind + name + ofType { + kind + name + } + } + } + } + } + } + } +} diff --git a/wcl/token.py b/wcl/oauth_token.py similarity index 98% rename from wcl/token.py rename to wcl/oauth_token.py index 25bb00b..d6c213e 100644 --- a/wcl/token.py +++ b/wcl/oauth_token.py @@ -1,6 +1,4 @@ -import time -import json -import pickle +import time, json, pickle from requests.exceptions import HTTPError from oauthlib.oauth2 import BackendApplicationClient diff --git a/wcl/query.py b/wcl/query.py index eb0ff84..cf30b73 100644 --- a/wcl/query.py +++ b/wcl/query.py @@ -1,24 +1,30 @@ +from copy import deepcopy + class Query: - params = {} - parent = None + # params + query_params = {} cacheable = True + + # internal objects + args = {} + children = None + fields = [] + name = None + parent = None paginator = { 'paginationField': None, - 'overrides': None + 'overrides': None, + 'callback': None } - args = {} - fields = [] - children = None def components( self ): - name = self.__class__.__name__ pagination_field = self.paginator.get( 'paginationField' ) return { - 'name': name[ 0 ].lower() + name[ 1: ], + 'name': self.name, 'args': { - argk: GQL_type_handler( argt, self.params.get( argk ) ) + argk: GQL_Type_Handler( argt, self.query_params.get( argk ) ) for argk, argt in self.args.items() - if self.params.get( argk ) is not None + if self.query_params.get( argk ) is not None }, 'fields': [ field if isinstance( field, dict ) else { 'name': field } @@ -27,29 +33,32 @@ def components( self ): ] } # yapf: disable - def __init__( self, params, cacheable=None ): - self.params = params.copy() - self.children = params.get( 'children' ) + def __init__( self, query_params, cacheable=None ): + self.query_params = deepcopy( query_params ) + self.children = self.query_params.get( 'children' ) self.tree = self.create_tree() self.string = self.stringify() self.cacheable = cacheable if cacheable is not None else self.cacheable def update( self, params ): - assert all([ type(self.params.get(key)) is type(params.get(key)) or params.get(key) is None for key in self.params]), 'Types of values do not match' - assert params != self.params, 'Params are unchanged' + assert all( [ + type( self.query_params.get( key ) ) is type( params.get( key ) ) or params.get( key ) is None + for key in self.query_params + ] ), 'Types of values do not match' + assert params != self.query_params, 'Params are unchanged' - self.params.update( params ) + self.query_params.update( params ) self.tree = self.create_tree() def create_tree( self ): - self.params.update( { + self.query_params.update( { 'children': self.components() } ) if self.parent is None: - return self.params.get( 'children' ) - return self.parent( self.params ).tree + return self.query_params.get( 'children' ) + return self.parent( self.query_params ).tree def stringify( self ): def recurse_nodes( node ): @@ -70,39 +79,39 @@ def recurse_nodes( node ): return '{' + recurse_nodes( self.tree ) + '}' -def GQL_type_handler( argt, value ): +def GQL_Type_Handler( argt, value ): if isinstance( argt, list ): return GQL_List( value, argt[ 0 ] ) return argt( value ) -class GraphQLType: +class GQL_Type: def __init__( self, value ): self.value = value -class GQL_Boolean( GraphQLType ): +class GQL_Boolean( GQL_Type ): def __str__( self ): return str( self.value and 'true' or 'false' ) -class GQL_String( GraphQLType ): +class GQL_String( GQL_Type ): def __str__( self ): return '"' + str( self.value ) + '"' -class GQL_Int( GraphQLType ): +class GQL_Int( GQL_Type ): def __str__( self ): return str( self.value ) -class GQL_Float( GraphQLType ): +class GQL_Float( GQL_Type ): def __str__( self ): return str( self.value ) -class GQL_Enum( GraphQLType ): +class GQL_Enum( GQL_Type ): allowed = [] def __str__( self ): assert self.value in self.allowed, f'{self.value} not in Enum {self.__class__.__name__}' return self.value -class GQL_List( GraphQLType ): +class GQL_List( GQL_Type ): def __init__( self, value, secondaryType ): super().__init__( value ) self.secondaryType = secondaryType @@ -219,3 +228,356 @@ class Events( Query ): } fields = [ 'data' ] + +class Reports( Query ): + parent = ReportData + paginator = { + 'paginationField': 'current_page', + 'overrides': 'page' + } + + args = { + 'endTime': GQL_Float, + 'guildID': GQL_Int, + 'guildName': GQL_String, + 'guildServerSlug': GQL_String, + 'guildServerRegion': GQL_String, + 'guildTagID': GQL_Int, + 'userID': GQL_Int, + 'limit': GQL_Int, + 'page': GQL_Int, + 'startTime': GQL_Float, + 'zoneID': GQL_Int, + 'gameZoneID': GQL_Int + } + + fields = [ + 'data', + 'total', + 'per_page', + 'current_page', + 'from', + 'to', + 'last_page', + 'has_more_pages' + ] + +# GQL 2.0 +# object_name( {argument_key: argument_value, ...} ){ [field, ...] } + +class GQL_OBJECT: + # Provided by instantiator + alias = None + args = {} + fields = {} + + # Provided by code generation + arg_types = {} + field_types = {} + name = None + parent = None + paginator = { + 'field': None, + 'replaces': None, + 'callback': None + } + + def __init__( self, args, fields ): + # Update name of child in fields and in the child object + # children may have multiple parents, and be called different things by each + if fields.get( 'child' ) is not None: + expected_name = None + child = fields[ 'child' ] + for name, t in self.field_types.items(): + if isinstance( child, t ): + expected_name = name + break + if expected_name is not None: + fields.update( { expected_name: child } ) + fields[ expected_name ].name = expected_name + fields.pop( 'child' ) + + + # Verify all arguments and fields are of the expected types + assert all( [ + isinstance( arg_v, expected_type ) + for arg_k, arg_v in args.items() + if ( expected_type := self.arg_types.get( arg_k ) ) + ] ), f'Not all args are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{args}\n{self.arg_types}' + assert all( [ + isinstance( field_v, expected_type ) + for field_k, field_v in fields.items() + if ( expected_type := self.field_types.get( field_k ) ) + ] ), f'Not all fields are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{fields}\n{self.field_types}' + + self.args = args + self.fields = fields + + def __str__( self ): + args = [ + f'{key}: {str( value )}' + for key, value in self.args.items() + if hasattr( value, '__str__' ) and key in self.arg_types.keys() + ] # yapf: disable + fields = [ + f'{str( value )}' + for key, value in self.fields.items() + if hasattr( value, '__str__' ) and key in self.field_types.keys() + ] # yapf: disable + args_str = ('(' if len( args ) > 0 else '') + ','.join( args ) + (')' if len( args ) > 0 else '') + fields_str = ('{' if len( fields ) > 0 else '') + ','.join( fields ) + ('}' if len( fields ) > 0 else '') + alias_str = self.alias + ': ' if self.alias is not None else '' + return f'{alias_str}{self.name}{args_str}{fields_str}' + + def tree( self ): + if self.parent is not None: + # print( f'creating {self.parent.__name__} with:\nargs: {self.args}\nfields: {self.fields | { "child": self }}') + return self.parent( self.args, self.fields | { 'child': self } ).tree() + return self + +class GQL_SCALAR: + def __init__( self, value ): + self.value = value + + def __str__( self ): + return f'{self.value}' + +class GQL_SCALAR_Boolean( GQL_SCALAR ): + def __str__( self ): + return f'{self.value and "true" or "false"}' + +class GQL_SCALAR_Float( GQL_SCALAR ): + pass + +class GQL_SCALAR_Int( GQL_SCALAR ): + pass + +class GQL_SCALAR_String( GQL_SCALAR ): + def __str__( self ): + return f'"{self.value}"' + +class GQL_ENUM: + allowed = [] + + def __init__( self, value ): + self.value = value + + def __str__( self ): + assert self.value in self.allowed, f'{self.value} is not in Enum {self.__class__.__name__}.' + return f'{self.value}' + +# class GQL_OBJECT_( GQL_Object ): +# def __init__( self, args, fields ): +# self.arg_types = { +# : GQL_, +# ... +# } +# self.field_types = { +# : GQL_, +# ... +# } +# self.name = +# self.parent = GQL_ +# self.paginator = { +# 'field': , +# 'replaces': , +# 'callback': +# } +# super().__init__( args, fields ) +class GQL_Test1( GQL_OBJECT ): + def __init__( self, args, fields ): + self.name = 'test-one' + self.field_types = { + 'newname-two': GQL_Test2 + } + super().__init__( args, fields ) + +class GQL_Test2( GQL_OBJECT ): + def __init__( self, args, fields ): + self.name = 'test-two' + self.parent = GQL_Test1 + super().__init__( args, fields ) + +if __name__ == '__main__': + import json + import request + from itertools import product + + class SchemaIntrospection: + schema_location = 'wcl/introspection_query.json' + tree = { 'name': '__schema' } + paginator = {} + cacheable = True + + def __str__( self ): + with open( self.schema_location, 'r' ) as handle: + data = handle.read() + return data + + schema_query = SchemaIntrospection() + schema_request_data = request.Request( schema_query ).data + t = set() + + enums = [] + objects = [] + for entry in schema_request_data[ 'types' ]: + # filter = [ + # 'name', + # 'kind', + # ] + # print([ f'{e}: {v}' for e, v in entry.items() if e in filter ]) + if entry.get( 'kind' ) == 'OBJECT': + objects.append( entry ) + if entry.get( 'kind' ) == 'ENUM': + enums.append( entry ) + + + # print( 'from .query import GQL_ENUM, GQL_OBJECT') + # for enum in enums: + # name = enum.get( 'name' ) + # descr = enum.get( 'description' ) + # print() + # if descr is not None: + # print( f'# {descr}') + # print( f'class GQL_ENUM_{name}( GQL_ENUM ):') + # print( ' allowed = [') + # max_len = max( [ + # len( enum_value.get( 'name', '' ) ) + # for enum_value in enum.get( 'enumValues' ) + # ] ) + 2 + # enum_values = [ + # { + # 'name': val.get( 'name' ), + # 'desc': val.get( 'description' ), + # } + # for val in enum.get( 'enumValues' ) + # ] + # for enum_value in enum_values: + # enum_value_name = enum_value.get( 'name', '' ) + '\',' + # enum_value_descr = enum_value.get( 'desc', '' ) + # print( f' \'{enum_value_name: <{max_len}} # {enum_value_descr}') + # print( ' ]') + + + def find_type( obj ): + base = obj.get( 'type' ) or obj.get( 'ofType' ) + if base[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + return base[ 'name' ] + return find_type( base ) + + def objects_with_matching_type( type_name ): + rets = [] + for obj in objects: + fields = obj.get( 'fields', [] ) + for field in fields: + if type_name == find_type( field ) and field.get( 'args' ) != []: + rets.append( field ) + return rets + + def object_name_from_type( type_obj ): + if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' + if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: + type_obj = type_obj[ 'ofType' ] + return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' + + def object_name( type_obj ): + if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + return f'{type_obj[ "name" ]}' + if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: + type_obj = type_obj[ 'ofType' ] + return f'{type_obj[ "name" ]}' + + def process_arg_or_field( entry ): + return { + 'TYPE': object_name_from_type( entry[ 'type' ] ), + 'IS_LIST': entry[ 'type' ][ 'kind' ] == 'LIST', + 'DESCRIPTION': entry[ 'description' ] + } + + def objects_have_matching_type( a, b ): + matches = [ + object_name( field[ 'type' ] ) == a[ 'name' ] + for field in b[ 'fields' ] + ] + return b[ 'fields' ][ matches.index( True ) ] if True in matches else False + + objects = [ + { + 'TYPE_NAME': base[ 'name' ], + 'NAME': variant_obj[ 'name' ], + 'VARIANT_COUNT': max( 1, len( objects_with_matching_type( base[ 'name' ] ) ) ), + 'PARENT': None, + 'ARGS': { + arg[ 'name' ]: process_arg_or_field( arg ) + for arg in variant_obj[ 'args' ] + }, + 'FIELDS': { + field[ 'name' ]: process_arg_or_field( field ) + for field in base[ 'fields' ] + }, + 'DESCRIPTION': [ + description + for description in [ base[ 'description' ], variant_obj[ 'description' ] ] + if description + ] + } + for base, variant in product( objects, objects ) + if base[ 'name' ][ :2 ] != '__' + if ( variant_obj := objects_have_matching_type( base, variant ) ) + ] + + # print(json.dumps(objects, indent=2)) + # objnames = { + # obj.get('NAME') + # for obj in objects + # } + objnames = set() + # print( len( objnames ), len( objects ) ) + for u, v in product (objects, objects): + if u.get('NAME') == v.get('NAME') and u != v: + print() + print(u.get('NAME'), u.get('TYPE_NAME')) + print(v.get('NAME'), v.get('TYPE_NAME')) + + # for obj in objects: + # type_name = obj[ 'name' ] + # if type_name != 'Report': + # continue + # descr = obj[ 'description' ] + # fields = [] + # for it in objects: + # candidates = it.get( 'fields', [] ) + # for candidate in candidates: + # if find_type( candidate ) == type_name: + # fields.append( candidate ) + # for k in fields: + # print( find_type( k ) ) + # print(k) + # print() + # if descr is not None: + # print( f'# {descr}') + # print( f'class GQL_OBJECT_{type_name}( GQL_OBJECT ):' ) + # print( ' def __init__( self, args, fields ):' ) + # print( ' self.arg_types = {' ) + # print( ' }' ) + # print( ' self.field_types = {' ) + # print( ' }' ) + # print( f' self.name = {type_name}' ) + # # for e, v in obj.items(): + # # if e == 'fields': + # # q = set() + # # for x in v: + # # print( x.get('name')) + # # print( x.get('type')) + # # for q in x.get( 'args' ): + # # for w, e in q.items(): + # # print( w, e) + # # print( x.get('args')) + # # for o, p in x.items(): + # # q.add( o ) + # # print( f'{e}: {v}') + # for e in obj.keys(): + # t.add( e ) + + # # print(t) diff --git a/wcl/query_generated.py b/wcl/query_generated.py new file mode 100644 index 0000000..fa702da --- /dev/null +++ b/wcl/query_generated.py @@ -0,0 +1,89 @@ +from .query import GQL_ENUM, GQL_OBJECT + +class GQL_ENUM_CharacterRankingMetricType( GQL_ENUM ): + allowed = [ + 'bosscdps', + 'bossdps', + 'bossndps', + 'bossrdps', + 'default', + 'dps', + 'hps', + 'krsi', + 'playerscore', + 'playerspeed', + 'cdps', + 'ndps', + 'rdps', + 'tankhps', + 'wdps', + 'healercombineddps', + 'healercombinedbossdps', + 'healercombinedcdps', + 'healercombinedbosscdps', + 'healercombinedndps', + 'healercombinedbossndps', + 'healercombinedrdps', + 'healercombinedbossrdps', + 'tankcombineddps', + 'tankcombinedbossdps', + 'tankcombinedcdps', + 'tankcombinedbosscdps', + 'tankcombinedndps', + 'tankcombinedbossndps', + 'tankcombinedrdps', + 'tankcombinedbossrdps ', + ] + +class GQL_ENUM_EventDataType( GQL_ENUM ): + allowed = [ + 'All', + 'Buffs', + 'Casts', + 'CombatantInfo', + 'DamageDone', + 'DamageTaken', + 'Deaths', + 'Debuffs', + 'Dispels', + 'Healing', + 'Interrupts', + 'Resources', + 'Summons', + 'Threat ', + ] + +class GQL_ENUM_ExternalBuffRankFilter( GQL_ENUM ): + allowed = [ + 'Any', + 'Require', + 'Exclude' + ] + +class GQL_ENUM_FightRankingMetricType( GQL_ENUM ): + allowed = [ + 'default', + 'execution', + 'feats', + 'score', + 'speed', + 'progress', + ] + +class GQL_ENUM_GraphDataType( GQL_ENUM ): + allowed = [ + 'Summary', + 'Buffs', + 'Casts', + 'DamageDone', + 'DamageTaken', + 'Deaths', + 'Debuffs', + 'Dispels', + 'Healing', + 'Interrupts', + 'Resources', + 'Summons', + 'Survivability', + 'Threat ', + ] diff --git a/wcl/requests.py b/wcl/request.py similarity index 92% rename from wcl/requests.py rename to wcl/request.py index bbbd584..ce7caeb 100644 --- a/wcl/requests.py +++ b/wcl/request.py @@ -1,4 +1,7 @@ -from . import caching, token +if __package__: + from . import caching, oauth_token +else: + import caching, oauth_token import requests import json @@ -7,7 +10,7 @@ @caching.cache class Request: v2_endpoint = 'https://www.warcraftlogs.com/api/v2/client' - token = token.Token() + token = oauth_token.Token() DEBUG = True @@ -17,7 +20,7 @@ def __init__( self, query, data=None ): def get_request( self ): def https_request( retry=0 ): - query_string = self.query.stringify() + query_string = str( self.query ) if self.DEBUG: print( 'requesting', query_string ) @@ -66,7 +69,7 @@ def drill_down( data, keys ): # print(json.dumps(resp, indent=2)) if resp.get( 'errors' ): # pyright: ignore - print( f'Failed to complete {self.query.string}' ) + print( f'Failed to complete {str( self.query )}' ) print( json.dumps( resp, indent=2 ) ) raise SystemExit diff --git a/wcl/schema.json b/wcl/schema.json new file mode 100644 index 0000000..7a48c7b --- /dev/null +++ b/wcl/schema.json @@ -0,0 +1,11780 @@ +{ + "data": { + "__schema": { + "queryType": { + "name": "Query" + }, + "mutationType": null, + "subscriptionType": null, + "types": [ + { + "kind": "OBJECT", + "name": "Query", + "description": null, + "fields": [ + { + "name": "characterData", + "description": "Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "CharacterData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameData", + "description": "Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..", + "args": [], + "type": { + "kind": "OBJECT", + "name": "GameData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guildData", + "description": "Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "GuildData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "progressRaceData", + "description": "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.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "ProgressRaceData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rateLimitData", + "description": "Obtain the rate limit data object to see how many points have been spent by this key.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "RateLimitData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "reportData", + "description": "Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "ReportData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "userData", + "description": "Obtain the user object that allows the retrieval of the authorized user's id and username.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "UserData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "worldData", + "description": "Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon\/raid zones, and encounters.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "WorldData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "CharacterData", + "description": "The CharacterData object enables the retrieval of single characters or filtered collections of characters.", + "fields": [ + { + "name": "character", + "description": "Obtain a specific character either by id or by name\/server_slug\/server_region.", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single character to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "name", + "description": "Optional. The name of a specific character. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a character.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverSlug", + "description": "Optional. The slug of a specific server. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific character. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Character", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "characters", + "description": "A collection of characters for a specific guild.", + "args": [ + { + "name": "guildID", + "description": "Required. The ID of a specific guild. Characters from that guild will be fetched.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "CharacterPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Int", + "description": "The `Int` scalar type represents non-fractional signed whole numeric\nvalues. Int can represent values between -(2^31) and 2^31 - 1. ", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "String", + "description": "The `String` scalar type represents textual data, represented as UTF-8\ncharacter sequences. The String type is most often used by GraphQL to\nrepresent free-form human-readable text.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Character", + "description": "A player character. Characters can earn individual rankings and appear in reports.", + "fields": [ + { + "name": "canonicalID", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "claimed", + "description": "Whether this character is claimed by the current user. Only accessible if accessed via the user API with the \"view-user-profile\" scope.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "classID", + "description": "The class id of the character.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "encounterRankings", + "description": "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.", + "args": [ + { + "name": "byBracket", + "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": { + "kind": "ENUM", + "name": "RankingCompareType", + "ofType": null + }, + "defaultValue": "Rankings" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Required. The specific encounter whose rankings should be fetched.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "includeCombatantInfo", + "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "includePrivateLogs", + "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": { + "kind": "ENUM", + "name": "CharacterRankingMetricType", + "ofType": null + }, + "defaultValue": "default" + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "role", + "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": { + "kind": "ENUM", + "name": "RoleType", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": { + "kind": "ENUM", + "name": "RankingTimeframeType", + "ofType": null + }, + "defaultValue": "Historical" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "faction", + "description": "The faction of the character.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameFaction", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameData", + "description": "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.", + "args": [ + { + "name": "specID", + "description": "Optional. A specific spec ID to retrieve information for. If omitted, the last observed spec on Armory (WoW) or Lodestone (FF) will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "forceUpdate", + "description": "Optional. Whether or not to force the updating of the character before returning the game data.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guildRank", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guilds", + "description": "All guilds that the character belongs to.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "hidden", + "description": "Whether or not the character has all its rankings hidden.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The ID of the character.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "level", + "description": "The level of the character.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the character.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "recentReports", + "description": "Recent reports for the character.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of recent reports to retrieve. If omitted, defaults to 10. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "10" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "ReportPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "server", + "description": "The server that the character belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Server", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zoneRankings", + "description": "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.", + "args": [ + { + "name": "byBracket", + "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": { + "kind": "ENUM", + "name": "RankingCompareType", + "ofType": null + }, + "defaultValue": "Rankings" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "includePrivateLogs", + "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": { + "kind": "ENUM", + "name": "CharacterRankingMetricType", + "ofType": null + }, + "defaultValue": "default" + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "role", + "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": { + "kind": "ENUM", + "name": "RoleType", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": { + "kind": "ENUM", + "name": "RankingTimeframeType", + "ofType": null + }, + "defaultValue": "Historical" + }, + { + "name": "zoneID", + "description": "Optional. If not specified, the latest unfrozen zone will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Boolean", + "description": "The `Boolean` scalar type represents `true` or `false`.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "RankingCompareType", + "description": "Whether or not rankings are compared against best scores for the entire tier or against all parses in a two week window.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Rankings", + "description": "Compare against rankings.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Parses", + "description": "Compare against all parses in a two week window.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "CharacterRankingMetricType", + "description": "All the possible metrics.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "bosscdps", + "description": "Boss cDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bossdps", + "description": "Boss damage per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bossndps", + "description": "Boss nDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bossrdps", + "description": "Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "default", + "description": "Choose an appropriate default depending on the other selected parameters.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "dps", + "description": "Damage per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "hps", + "description": "Healing per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "krsi", + "description": "Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "playerscore", + "description": "Score. Used by WoW Mythic dungeons and by ESO trials.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "playerspeed", + "description": "Speed. Not supported by every zone.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "cdps", + "description": "cDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ndps", + "description": "nDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rdps", + "description": "rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankhps", + "description": "Healing done per second to tanks.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "wdps", + "description": "Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombineddps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedbossdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedcdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedbosscdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedndps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedbossndps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedrdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "healercombinedbossrdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombineddps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedbossdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedcdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedbosscdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedndps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedbossndps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedrdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankcombinedbossrdps", + "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "RoleType", + "description": "Used to specify a tank, healer or DPS role.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Any", + "description": "Fetch any role..", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DPS", + "description": "Fetch the DPS role only.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Healer", + "description": "Fetch the healer role only.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Tank", + "description": "Fetch the tanking role only.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "RankingTimeframeType", + "description": "Whether or not rankings are today or historical.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Today", + "description": "Compare against today's rankings.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Historical", + "description": "Compare against historical rankings.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "JSON", + "description": "", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameFaction", + "description": "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.", + "fields": [ + { + "name": "id", + "description": "An integer representing the faction id.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the faction.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Guild", + "description": "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.", + "fields": [ + { + "name": "attendance", + "description": null, + "args": [ + { + "name": "guildTagID", + "description": "Optional. Whether or not to filter the attendance to a specific guild tag.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "limit", + "description": "Optional. The number of reports to retrieve per page. If omitted, defaults to 16. The maximum allowed value is 25, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "16" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "zoneID", + "description": "Optional. Whether or not to filter the attendance table to a specific zone.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GuildAttendancePagination", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "competitionMode", + "description": "Whether or not the guild has competition mode enabled.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": "The description for the guild that is displayed with the guild name on the site.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "faction", + "description": "The faction of the guild.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameFaction", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The ID of the guild.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the guild.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "server", + "description": "The server that the guild belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Server", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "stealthMode", + "description": "Whether or not the guild has stealth mode enabled.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tags", + "description": "The tags used to label reports. In the site UI, these are called raid teams.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GuildTag", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "members", + "description": "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.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "CharacterPagination", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "currentUserRank", + "description": "The current user's rank within the guild. Only accessible via user authentication with the \"view-user-profile\" scope.", + "args": [], + "type": { + "kind": "ENUM", + "name": "GuildRank", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zoneRanking", + "description": "The guild's ranking for a zone. If `zoneId` is unset or null, uses the latest zone.", + "args": [ + { + "name": "zoneId", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GuildZoneRankings", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildAttendancePagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GuildAttendance", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildAttendance", + "description": "Attendance for a specific report within a guild.", + "fields": [ + { + "name": "code", + "description": "The code of the report for the raid night.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "players", + "description": "The players that attended that raid night.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PlayerAttendance", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "startTime", + "description": "The start time of the raid night.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zone", + "description": "The principal zone of the raid night.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PlayerAttendance", + "description": "Attendance for a specific player on a specific raid night.", + "fields": [ + { + "name": "name", + "description": "The name of the player.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": "The class of the player.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "presence", + "description": "Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "Float", + "description": "The `Float` scalar type represents signed double-precision fractional\nvalues as specified by\n[IEEE 754](http:\/\/en.wikipedia.org\/wiki\/IEEE_floating_point). ", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Zone", + "description": "A single zone from an expansion that represents a raid, dungeon, arena, etc.", + "fields": [ + { + "name": "id", + "description": "The ID of the zone.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "brackets", + "description": "The bracket information for this zone. This field will be null if the zone does not support brackets.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Bracket", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "difficulties", + "description": "A list of all the difficulties supported for this zone.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Difficulty", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "encounters", + "description": "The encounters found within this zone.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Encounter", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "expansion", + "description": "The expansion that this zone belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Expansion", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "frozen", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the zone.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "partitions", + "description": "A list of all the partitions supported for this zone.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Partition", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Bracket", + "description": "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.", + "fields": [ + { + "name": "min", + "description": "An integer representing the minimum value used by bracket number 1, etc.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "max", + "description": "An integer representing the value used by bracket N when there are a total of N brackets, etc.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bucket", + "description": "A float representing the value to increment when moving from bracket 1 to bracket N, etc.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": "The localized name of the bracket type.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Difficulty", + "description": "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.", + "fields": [ + { + "name": "id", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name for the difficulty level.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "sizes", + "description": "A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Encounter", + "description": "A single encounter for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the encounter.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the encounter.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "characterRankings", + "description": "Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "args": [ + { + "name": "bracket", + "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "filter", + "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "page", + "description": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "leaderboard", + "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": { + "kind": "ENUM", + "name": "LeaderboardRank", + "ofType": null + }, + "defaultValue": "Any" + }, + { + "name": "hardModeLevel", + "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": { + "kind": "ENUM", + "name": "HardModeLevelRankFilter", + "ofType": null + }, + "defaultValue": "Any" + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific player metric like dps or hps. If omitted, an appropriate default player metric for the zone will be chosen.", + "type": { + "kind": "ENUM", + "name": "CharacterRankingMetricType", + "ofType": null + }, + "defaultValue": "default" + }, + { + "name": "includeCombatantInfo", + "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. If omitted, data for all classes will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "externalBuffs", + "description": "Optional. Controls whether to include ranks with\/without external buffs. Most games and zones do not support this filter and will quietly ignore it.", + "type": { + "kind": "ENUM", + "name": "ExternalBuffRankFilter", + "ofType": null + }, + "defaultValue": "Any" + }, + { + "name": "covenantID", + "description": "Optional. The covenant ID to filter to if viewing Shadowlands rankings.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "soulbindID", + "description": "Optional. The soulbind ID to filter to if viewing Shadowlands rankings.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "fightRankings", + "description": "Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "args": [ + { + "name": "bracket", + "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "filter", + "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "page", + "description": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "leaderboard", + "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": { + "kind": "ENUM", + "name": "LeaderboardRank", + "ofType": null + }, + "defaultValue": "Any" + }, + { + "name": "hardModeLevel", + "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": { + "kind": "ENUM", + "name": "HardModeLevelRankFilter", + "ofType": null + }, + "defaultValue": "Any" + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific fight metric like speed or execution. If omitted, an appropriate default fight metric for the zone will be chosen.", + "type": { + "kind": "ENUM", + "name": "FightRankingMetricType", + "ofType": null + }, + "defaultValue": "default" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zone", + "description": "The zone that this encounter is found in.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "journalID", + "description": "The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "LeaderboardRank", + "description": "Source of the rank. Most ranks only support log ranks, but some games (ESO) and content types (Retail WoW M+) support leaderboard ranks with no backing log.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Any", + "description": "All ranks are included.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LogsOnly", + "description": "Only include ranks with a backing log.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "HardModeLevelRankFilter", + "description": "Hard mode level filter. Used for WoW Classic Hard Modes. For ESO hard modes, use `difficulty`. Hard mode levels range from 0-4, with 0 being normal mode and 4 being the highest hard mode.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Any", + "description": "Any hard mode level (including normal mode).", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Highest", + "description": "The highest hard mode level. Convenience alias for hard mode level 4.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "NormalMode", + "description": "The normal (non-hard) mode level. Convenience alias for hard mode level 0.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Level0", + "description": "Hard mode level 0.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Level1", + "description": "Hard mode level 1.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Level2", + "description": "Hard mode level 2.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Level3", + "description": "Hard mode level 3.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Level4", + "description": "Hard mode level 4.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "ExternalBuffRankFilter", + "description": "Whether to include ranks with major external buffs. Not all metrics, zones and games support this. It will be ignored if unsupported.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Any", + "description": "Include all ranks, regardless of external buffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Require", + "description": "Only include ranks that DO CONTAIN external buffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Exclude", + "description": "Only include ranks that DO NOT CONTAIN external buffs.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "FightRankingMetricType", + "description": "All the possible metrics.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "default", + "description": "Choose an appropriate default depending on the other selected parameters.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "execution", + "description": "A metric that rewards minimizing deaths and damage taken.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "feats", + "description": "Feats of strength in WoW or Challenges in FF.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "score", + "description": "For Mythic+ dungeons in WoW, represents the team's score. Used for ESO trials and dungeons also.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "speed", + "description": "Speed metric, based off the duration of the fight.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "progress", + "description": "Progress metric, based off when the fight was defeated.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Expansion", + "description": "A single expansion for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the expansion.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the expansion.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zones", + "description": "The zones (e.g., raids and dungeons) supported for this expansion.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Partition", + "description": "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.", + "fields": [ + { + "name": "id", + "description": "An integer representing a specific partition within a zone.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name for partition.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "compactName", + "description": "The compact localized name for the partition. Typically an abbreviation to conserve space.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "default", + "description": "Whether or not the partition is the current default when viewing rankings or statistics for the zone.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Server", + "description": "A single server. Servers correspond to actual game servers that characters and guilds reside on.", + "fields": [ + { + "name": "id", + "description": "The ID of the server.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the server in the locale of the subregion that the server belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "normalizedName", + "description": "The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "slug", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "region", + "description": "The region that this server belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Region", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subregion", + "description": "The subregion that this server belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Subregion", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guilds", + "description": "The guilds found on this server (and any servers connected to this one.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of guilds to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "10" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GuildPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "characters", + "description": "The characters found on this server (and any servers connected to this one.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "10" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "CharacterPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Region", + "description": "A single region for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the region.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "compactName", + "description": "The localized compact name of the region, e.g., US for United States.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the region.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "slug", + "description": "The slug for the region, usable when looking up characters and guilds by server.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subregions", + "description": "The subregions found within this region.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Subregion", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "servers", + "description": "The servers found within this region.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "ServerPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Subregion", + "description": "A single subregion. Subregions are used to divide a region into sub-categories, such as French or German subregions of a Europe region.", + "fields": [ + { + "name": "id", + "description": "The ID of the subregion.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the subregion.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "region", + "description": "The region that this subregion is found in.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Region", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "servers", + "description": "The servers found within this region.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "ServerPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ServerPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Server", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "CharacterPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Character", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildTag", + "description": "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.", + "fields": [ + { + "name": "id", + "description": "The ID of the tag.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guild", + "description": "The guild that the tag belongs to.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the tag.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "GuildRank", + "description": "Rank within a guild or team on the website. This is separate from in-game ranks and does NOT correspond to the rank of the user or character in-game.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "NonMember", + "description": "The user is not a member of this guild or team.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Applicant", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Recruit", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Member", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Officer", + "description": null, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "GuildMaster", + "description": null, + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildZoneRankings", + "description": "A guild's rankings within a zone.", + "fields": [ + { + "name": "progress", + "description": "The progress ranks for the guild. Always uses the highest difficulty.", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "WorldRegionServerRankPositions", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "speed", + "description": "The all-star based speed rank for the guild.", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "difficulty", + "description": "Raid difficulty.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "WorldRegionServerRankPositions", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "completeRaidSpeed", + "description": "The complete raid speed ranks for the guild. Most non-Classic WoW zones do not support complete raid ranks.", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "difficulty", + "description": "Raid difficulty.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "WorldRegionServerRankPositions", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "WorldRegionServerRankPositions", + "description": "A collection containing some combination of world, region, and server ranks.", + "fields": [ + { + "name": "worldRank", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Rank", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "regionRank", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Rank", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "serverRank", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "Rank", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Rank", + "description": null, + "fields": [ + { + "name": "number", + "description": "The ordinal rank (usually written \"Rank N\"). Rank 1 = highest.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "percentile", + "description": "The percentile of the rank as an integer in [0, 100]. Always null for guild ranks.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "color", + "description": "The color class used by the site for this rank.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Report", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "Report", + "description": "A single report uploaded by a player to a guild or personal logs.", + "fields": [ + { + "name": "code", + "description": "The report code, a unique value used to identify the report.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "endTime", + "description": "The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "events", + "description": "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.", + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": { + "kind": "ENUM", + "name": "EventDataType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": { + "kind": "ENUM", + "name": "HostilityType", + "ofType": null + }, + "defaultValue": "Friendlies" + }, + { + "name": "includeResources", + "description": "Optional. Whether or not to include detailed unit resources for actors. Adds substantially to bandwidth, so defaults to off.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": { + "kind": "ENUM", + "name": "KillType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "limit", + "description": "Optional. How many events to retrieve. Allowed value ranges are 100-10000. The default value is 300.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "300" + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if is a priority, and you do not care about the names.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + }, + { + "name": "useAbilityIDs", + "description": "Optional. Whether or not to include detailed ability information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + }, + { + "name": "useActorIDs", + "description": "Optional. Whether or not to include detailed actor information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "OBJECT", + "name": "ReportEventPaginator", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "exportedSegments", + "description": "The number of exported segments in the report. This is how many segments have been processed for rankings.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "fights", + "description": "A set of fights with details about participating players.", + "args": [ + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": { + "kind": "ENUM", + "name": "KillType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportFight", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "graph", + "description": "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.", + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": { + "kind": "ENUM", + "name": "GraphDataType", + "ofType": null + }, + "defaultValue": "Summary" + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": { + "kind": "ENUM", + "name": "HostilityType", + "ofType": null + }, + "defaultValue": "Friendlies" + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": { + "kind": "ENUM", + "name": "KillType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "viewBy", + "description": "Optional. Whether to view by source, by target or by ability.", + "type": { + "kind": "ENUM", + "name": "ViewType", + "ofType": null + }, + "defaultValue": "Default" + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guild", + "description": "The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guildTag", + "description": "The guild tag that the report belongs to. If this is null, then the report was not tagged.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "GuildTag", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "owner", + "description": "The user that uploaded the report.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "User", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "masterData", + "description": "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.", + "args": [ + { + "name": "translate", + "description": "Optional. Whether or not the actors and abilities in the master data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names of abilities and actors.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + } + ], + "type": { + "kind": "OBJECT", + "name": "ReportMasterData", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "playerDetails", + "description": "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.", + "args": [ + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": { + "kind": "ENUM", + "name": "KillType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rankedCharacters", + "description": "A list of all characters that ranked on kills in the report.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Character", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rankings", + "description": "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.", + "args": [ + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": { + "kind": "ENUM", + "name": "RankingCompareType", + "ofType": null + }, + "defaultValue": "Rankings" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "playerMetric", + "description": "Optional. You can filter to a specific player metric like dps or hps.", + "type": { + "kind": "ENUM", + "name": "ReportRankingMetricType", + "ofType": null + }, + "defaultValue": "default" + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": { + "kind": "ENUM", + "name": "RankingTimeframeType", + "ofType": null + }, + "defaultValue": "Today" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "region", + "description": "The region of the report.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Region", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "revision", + "description": "The revision of the report. This number is increased when reports get re-exported.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "segments", + "description": "The number of uploaded segments in the report.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "startTime", + "description": "The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "table", + "description": "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.", + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": { + "kind": "ENUM", + "name": "TableDataType", + "ofType": null + }, + "defaultValue": "Summary" + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": "[]" + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": { + "kind": "ENUM", + "name": "HostilityType", + "ofType": null + }, + "defaultValue": "Friendlies" + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": { + "kind": "ENUM", + "name": "KillType", + "ofType": null + }, + "defaultValue": "All" + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"Any\"" + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "true" + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "viewBy", + "description": "Optional. Whether to view by source, by target or by ability.", + "type": { + "kind": "ENUM", + "name": "ViewType", + "ofType": null + }, + "defaultValue": "Default" + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "title", + "description": "A title for the report.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "visibility", + "description": "The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zone", + "description": "The principal zone that the report contains fights for. Null if no supported zone exists.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "archiveStatus", + "description": "Whether this report has been archived. Events, tables, and graphs for archived reports are inaccessible unless the retrieving user has a subscription including archive access.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "ReportArchiveStatus", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "phases", + "description": "Phase information for all boss encounters observed in this report. This requires loading fight data, but does not double-charge API points if you load fights and phases.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "EncounterPhases", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "EventDataType", + "description": "The type of events or tables to examine.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "All", + "description": "All Events", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Buffs", + "description": "Buffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Casts", + "description": "Casts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "CombatantInfo", + "description": "Combatant info events (includes gear).", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageDone", + "description": "Damage done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageTaken", + "description": "Damage taken.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Deaths", + "description": "Deaths.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Debuffs", + "description": "Debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Dispels", + "description": "Dispels.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Healing", + "description": "Healing done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Interrupts", + "description": "Interrupts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Resources", + "description": "Resources.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Summons", + "description": "Summons", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Threat", + "description": "Threat.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "HostilityType", + "description": "Whether or not to fetch information for friendlies or enemies.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Friendlies", + "description": "Fetch information for friendlies.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Enemies", + "description": "Fetch information for enemies.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "KillType", + "description": "A filter for kills vs wipes and encounters vs trash.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "All", + "description": "Include trash and encounters.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Encounters", + "description": "Only include encounters (kills and wipes).", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Kills", + "description": "Only include encounters that end in a kill.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Trash", + "description": "Only include trash.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Wipes", + "description": "Only include encounters that end in a wipe.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportEventPaginator", + "description": "The ReportEventPaginator represents a paginated list of report events.", + "fields": [ + { + "name": "data", + "description": "The list of events obtained.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "nextPageTimestamp", + "description": "A timestamp to pass in as the start time when fetching the next page of data.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportFight", + "description": "The ReportFight represents a single fight that occurs in the report.", + "fields": [ + { + "name": "averageItemLevel", + "description": "The average item level of the players in the fight.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bossPercentage", + "description": "The percentage health of the active boss or bosses at the end of a fight.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "boundingBox", + "description": "The bounding box that encloses the positions of all players\/enemies in the fight.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "ReportMapBoundingBox", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "classicSeasonID", + "description": "The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "completeRaid", + "description": "Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "difficulty", + "description": "The difficulty setting for the raid, dungeon, or arena. Null for trash.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "dungeonPulls", + "description": "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.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportDungeonPull", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "encounterID", + "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "endTime", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enemyNPCs", + "description": "Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportFightNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enemyPets", + "description": "Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportFightNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enemyPlayers", + "description": "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.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "fightPercentage", + "description": "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.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "friendlyNPCs", + "description": "Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportFightNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "friendlyPets", + "description": "Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportFightNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "friendlyPlayers", + "description": "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.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameZone", + "description": "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.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "GameZone", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "hardModeLevel", + "description": "The hard mode level of the fight. Most fights don't support optional hard modes. This only applies to bosses like Sartharion.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "inProgress", + "description": "Whether or not the fight is still in progress. If this field is false, it means the entire fight has been uploaded.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "keystoneAffixes", + "description": "The affixes for a Mythic+ dungeon.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "keystoneBonus", + "description": "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.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "keystoneLevel", + "description": "The keystone level for a Mythic+ dungeon.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "keystoneTime", + "description": "The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "kill", + "description": "Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was a wipe or a failed run, etc..", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "lastPhase", + "description": "The phase that the encounter was in when the fight ended. Counts up from 1 based off the phase type (i.e., normal phase vs intermission).", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "lastPhaseAsAbsoluteIndex", + "description": "The phase that the encounter was in when the fight ended. Always increases from 0, so a fight with three real phases and two intermissions would count up from 0 to 4.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "lastPhaseIsIntermission", + "description": "Whether or not the phase that the encounter was in when the fight ended was an intermission or not.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "layer", + "description": "The layer of a Torghast run.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maps", + "description": "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.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportMap", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "originalEncounterID", + "description": "Some boss fights may be converted to trash fights (encounterID = 0). When this occurs, `originalEncounterID` contains the original ID of the encounter.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "phaseTransitions", + "description": "List of observed phase transitions during the fight.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PhaseTransition", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rating", + "description": "The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "size", + "description": "The group size for the raid, dungeon, or arena. Null for trash.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "startTime", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "talentImportCode", + "description": "The import\/export code for a Retail Dragonflight talent build. Will be null for a classic or pre-Dragonflight fight.", + "args": [ + { + "name": "actorID", + "description": "The friendly player actor to generate talents for. Result will be null for unknown or non-player actors. Use the ReportMasterData or the friendlyPlayers field on this type to get the list of friendly player actor IDs.", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "wipeCalledTime", + "description": "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.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportMapBoundingBox", + "description": "The ReportMapBoundingBox is a box that encloses the positions of all players and enemies in a fight or dungeon pull.", + "fields": [ + { + "name": "minX", + "description": "The smallest X position.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maxX", + "description": "The largest X position.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "minY", + "description": "The smallest Y position.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maxY", + "description": "The largest Y position.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportDungeonPull", + "description": "The ReportDungeonPull represents a single pull that occurs in a containing dungeon.", + "fields": [ + { + "name": "boundingBox", + "description": "The bounding box that encloses the positions of all players\/enemies in the fight.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "ReportMapBoundingBox", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "encounterID", + "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "endTime", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enemyNPCs", + "description": "Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportDungeonPullNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "kill", + "description": "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..", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maps", + "description": "All the maps that were involved in a pull.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportMap", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "startTime", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "x", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "y", + "description": "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.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportDungeonPullNPC", + "description": "The ReportDungeonPullNPC represents participation info within a single dungeon pull for an NPC.", + "fields": [ + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameID", + "description": "The game ID of the actor, e.g., so it can be looked up on external Web sites.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "minimumInstanceID", + "description": "The lowest instance ID seen during the pull.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maximumInstanceID", + "description": "The highest instance ID seen during the pull.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "minimumInstanceGroupID", + "description": "The lowest instance group ID seen during the pull.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maximumInstanceGroupID", + "description": "The highest instance group ID seen during the pull.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportMap", + "description": "The ReportMap represents a single map that a fight can occur on.", + "fields": [ + { + "name": "id", + "description": "The map's game ID.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportFightNPC", + "description": "The ReportFightNPC represents participation info within a single fight for an NPC.", + "fields": [ + { + "name": "gameID", + "description": "The game ID of the actor. This ID is used in events to identify sources and targets.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "instanceCount", + "description": "How many instances of the NPC were seen during the fight.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "groupCount", + "description": "How many packs of the NPC were seen during the fight.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "petOwner", + "description": "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.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameZone", + "description": "A single zone for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the zone.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the zone. Will be null if no localization information exists for the zone.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PhaseTransition", + "description": "A spartan representation of phase transitions during a fight.", + "fields": [ + { + "name": "id", + "description": "The 1-indexed id of the phase. Phase IDs are absolute within a fight: phases with the same ID correspond to the same semantic phase.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "startTime", + "description": "The report-relative timestamp of the transition into the phase. The phase ends at the beginning of the next phase, or at the end of the fight.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "GraphDataType", + "description": "The type of graph to examine.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Summary", + "description": "Summary Overview", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Buffs", + "description": "Buffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Casts", + "description": "Casts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageDone", + "description": "Damage done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageTaken", + "description": "Damage taken.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Deaths", + "description": "Deaths.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Debuffs", + "description": "Debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Dispels", + "description": "Dispels.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Healing", + "description": "Healing done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Interrupts", + "description": "Interrupts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Resources", + "description": "Resources.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Summons", + "description": "Summons", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Survivability", + "description": "Survivability (death info across multiple pulls).", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Threat", + "description": "Threat.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "ViewType", + "description": "Whether the view is by source, target, or ability.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Default", + "description": "Use the same default that the web site picks based off the other selected parameters.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Ability", + "description": "View by ability.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Source", + "description": "View. by source.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Target", + "description": "View by target.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "User", + "description": "A single user of the site. Most fields can only be accessed when authenticated as that user with the \"view-user-profile\" scope.", + "fields": [ + { + "name": "id", + "description": "The ID of the user.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the user.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guilds", + "description": "The list of guilds to which the user belongs. Only accessible via user authentication when you have the \"view-user-profile\" scope.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "characters", + "description": "The characters claimed by this user. Only accessible via user authentication when you have the \"view-user-profile\" scope.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Character", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "battleTag", + "description": "The battle tag of the user if they have linked it.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportMasterData", + "description": "The ReporMastertData object contains information about the log version of a report, as well as the actors and abilities used in the report.", + "fields": [ + { + "name": "logVersion", + "description": "The version of the client parser that was used to parse and upload this log file.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameVersion", + "description": "The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "lang", + "description": "The auto-detected locale of the report. This is the source language of the original log file.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "abilities", + "description": "A list of every ability that occurs in the report.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportAbility", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "actors", + "description": "A list of every actor (player, NPC, pet) that occurs in the report.", + "args": [ + { + "name": "type", + "description": "Optional. A filter on the actors in a report. If the type field of the actor matches the specified type field, it will be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "subType", + "description": "Optional. A filter on the actors in a report. If the subType field of the actor matches the specified subType field, it will be included.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "ReportActor", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportAbility", + "description": "The ReportAbility represents a single ability that occurs in the report.", + "fields": [ + { + "name": "gameID", + "description": "The game ID of the ability.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "An icon to use for the ability.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the actor.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": "The type of the ability. This represents the type of damage (e.g., the spell school in WoW).", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportActor", + "description": "The ReportActor represents a single player, pet or NPC that occurs in the report.", + "fields": [ + { + "name": "gameID", + "description": "The game ID of the actor.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The name of the actor.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "petOwner", + "description": "The report ID of the actor's owner if the actor is a pet.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "server", + "description": "The normalized server name of the actor.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subType", + "description": "The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": "The type of the actor, i.e., if it is a player, pet or NPC.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "ReportRankingMetricType", + "description": "All the possible metrics.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "bossdps", + "description": "Boss damage per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "bossrdps", + "description": "Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "default", + "description": "Choose an appropriate default depending on the other selected parameters.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "dps", + "description": "Damage per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "hps", + "description": "Healing per second.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "krsi", + "description": "Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "playerscore", + "description": "Score. Used by WoW Mythic dungeons and by ESO trials.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "playerspeed", + "description": "Speed. Not supported by every zone.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "rdps", + "description": "rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "tankhps", + "description": "Healing done per second to tanks.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "wdps", + "description": "Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "TableDataType", + "description": "The type of table to examine.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Summary", + "description": "Summary Overview", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Buffs", + "description": "Buffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Casts", + "description": "Casts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageDone", + "description": "Damage done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "DamageTaken", + "description": "Damage taken.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Deaths", + "description": "Deaths.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Debuffs", + "description": "Debuffs.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Dispels", + "description": "Dispels.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Healing", + "description": "Healing done.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Interrupts", + "description": "Interrupts.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Resources", + "description": "Resources.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Summons", + "description": "Summons", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Survivability", + "description": "Survivability (death info across multiple pulls).", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Threat", + "description": "Threat.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportArchiveStatus", + "description": "The archival status of a report.", + "fields": [ + { + "name": "isArchived", + "description": "Whether the report has been archived.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isAccessible", + "description": "Whether the current user can access the report. Always true if the report is not archived, and always false if not using user authentication.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "archiveDate", + "description": "The date on which the report was archived (if it has been archived).", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "EncounterPhases", + "description": null, + "fields": [ + { + "name": "encounterID", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "separatesWipes", + "description": "Whether this phase splits the fight. Not currently used in Warcraft games.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "phases", + "description": "Phase metadata for all phases in this encounter.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "PhaseMetadata", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "PhaseMetadata", + "description": "Information about a phase from a boss encounter.", + "fields": [ + { + "name": "id", + "description": "Phase ID. 1-indexed", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isIntermission", + "description": "Whether this phase represents an intermission.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameData", + "description": "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.", + "fields": [ + { + "name": "abilities", + "description": "The player and enemy abilities for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of abilities to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameAbilityPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ability", + "description": "Obtain a single ability for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific ability to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameAbility", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "achievement", + "description": "Obtain a single achievement for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific achievement to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameAchievement", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "achievements", + "description": "Achievements for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of achievements to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameAchievementPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "affix", + "description": "Obtain a single affix for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific affix to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameAffix", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "affixes", + "description": "The affixes for the game.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameAffix", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "class", + "description": "Obtain a single class for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific class to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "faction_id", + "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "zone_id", + "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameClass", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "classes", + "description": "Obtain the supported classes for the game.", + "args": [ + { + "name": "faction_id", + "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "zone_id", + "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameClass", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enchant", + "description": "Obtain a single enchant for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific enchant to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameEnchant", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enchants", + "description": "Enchants for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of enchants to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameEnchantPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "factions", + "description": "Obtain all the factions that guilds and players can belong to.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameFaction", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "item", + "description": "Obtain a single item for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific item to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameItem", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "item_set", + "description": "Obtain a single item set for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific item set to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameItemSet", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "item_sets", + "description": "Item sets for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of item sets to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameItemSetPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "items", + "description": "Items for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of items to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameItemPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "map", + "description": "Obtain a single map for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific map to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameMap", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "maps", + "description": "Maps for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of maps to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameMapPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "npc", + "description": "Obtain a single NPC for the game.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific NPC to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameNPC", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "npcs", + "description": "NPCs for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of NPCs to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameNPCPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zone", + "description": "Obtain a single zone for the game, not to be confused with the worldData zones for ranking bosses and dungeons.", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific game zone to retrieve by its id.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GameZone", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zones", + "description": "Zones for the game.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of game zones to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + } + ], + "type": { + "kind": "OBJECT", + "name": "GameZonePagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameAbilityPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameAbility", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameAbility", + "description": "A single ability for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the ability.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "The icon for the ability.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the ability. Will be null if no localization information exists for the ability.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameAchievement", + "description": "A single achievement for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the achievement.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "The icon for the achievement.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the achievement. Will be null if no localization information exists for the achievement.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameAchievementPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameAchievement", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameAffix", + "description": "A single affix for Mythic Keystone dungeons.", + "fields": [ + { + "name": "id", + "description": "The ID of the affix.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "The icon for the affix.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the affix. Will be null if no localization information exists for the affix.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameClass", + "description": "A single player class for the game.", + "fields": [ + { + "name": "id", + "description": "An integer used to identify the class.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the class.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "slug", + "description": "A slug used to identify the class.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "specs", + "description": "The specs supported by the class.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameSpec", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameSpec", + "description": "A spec for a given player class.", + "fields": [ + { + "name": "id", + "description": "An integer used to identify the spec.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "class", + "description": "The player class that the spec belongs to.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "GameClass", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the class.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "slug", + "description": "A slug used to identify the spec.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameEnchant", + "description": "A single enchant for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the enchant.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the enchant. Will be null if no localization information exists for the enchant.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameEnchantPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameEnchant", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameItem", + "description": "A single item for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the item.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "icon", + "description": "The icon for the item.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the item. Will be null if no localization information exists for the item.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameItemSet", + "description": "A single item set for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the item set.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the item set. Will be null if no localization information exists for the item set.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameItemSetPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameItemSet", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameItemPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameItem", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameMap", + "description": "A single map for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the map.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the map. Will be null if no localization information exists for the map.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameMapPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameMap", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameNPC", + "description": "A single NPC for the game.", + "fields": [ + { + "name": "id", + "description": "The ID of the NPC.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": "The localized name of the NPC. Will be null if no localization information exists for the NPC.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameNPCPagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameNPC", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GameZonePagination", + "description": null, + "fields": [ + { + "name": "data", + "description": "List of items on the current page", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "GameZone", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "from", + "description": "Number of the first item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "to", + "description": "Number of the last item returned", + "args": [], + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "GuildData", + "description": "The GuildData object enables the retrieval of single guilds or filtered collections of guilds.", + "fields": [ + { + "name": "guild", + "description": "Obtain a specific guild either by id or by name\/serverSlug\/serverRegion.", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single guild to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "name", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Guild", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "guilds", + "description": "The set of all guilds supported by the site. Can be optionally filtered to a specific server id.", + "args": [ + { + "name": "limit", + "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "serverID", + "description": "Optional. The ID of a specific server. If present, only guilds from that server (and any connected servers) will be fetched.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Must be used in conjunction with serverRegion to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific server. Must be used in conjunction with serverSlug to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "GuildPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ProgressRaceData", + "description": "A way to obtain data for the top guilds involved in an ongoing world first or realm first progress race.", + "fields": [ + { + "name": "progressRace", + "description": "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.", + "args": [ + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "serverSubregion", + "description": "Optional. The short name of a subregion to filter to. Must be paired with serverRegion. Rankings for that specific subregion will be fetched.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"\"" + }, + { + "name": "zoneID", + "description": "Optional. If not specified, the latest zone will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "competitionID", + "description": "Optional. If not specified, the race to world first competition will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "difficulty", + "description": "Optional. If not specified, the highest difficulty will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "size", + "description": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "guildID", + "description": "Optional. The ID of a single guild to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "detailedComposition", + "description": "Detailed composition data for a given guild and encounter.", + "args": [ + { + "name": "competitionID", + "description": "Optional. If not specified, the race to world first competition will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "guildID", + "description": "Optional. The ID of a single guild to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "encounterID", + "description": "Optional. If not specified, the current boss that is being pulled will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "difficulty", + "description": "Optional. If not specified, the highest difficulty will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "size", + "description": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "RateLimitData", + "description": "A way to obtain your current rate limit usage.", + "fields": [ + { + "name": "limitPerHour", + "description": "The total amount of points this API key can spend per hour.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "pointsSpentThisHour", + "description": "The total amount of points spent during this hour.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "pointsResetIn", + "description": "The number of seconds remaining until the points reset.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ReportData", + "description": "The ReportData object enables the retrieval of single reports or filtered collections of reports.", + "fields": [ + { + "name": "report", + "description": "Obtain a specific report by its code.", + "args": [ + { + "name": "code", + "description": "Required. The code of a single report to retrieve.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Report", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "reports", + "description": "A set of reports for a specific guild, guild tag, or user.", + "args": [ + { + "name": "endTime", + "description": "Optional. A UNIX timestamp with millisecond precision representing the end time for a report range. If omitted, defaults to the current time in milliseconds.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildID", + "description": "Optional. The ID of a specific guild. Reports from that guild will be fetched.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with guildServerSlug and guildServerRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildServerSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildServerRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "guildTagID", + "description": "Optional. The ID of a specific guild tag. Reports from that guild tag will be fetched. This will take precedence over all other guild arguments.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "userID", + "description": "Optional. The ID of a specific user. Reports from that user's personal logs will be fetched.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "100" + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "1" + }, + { + "name": "startTime", + "description": "Optional. A UNIX timestamp with millisecond precision representing a start time for a report range. If omitted, defaults to 0.", + "type": { + "kind": "SCALAR", + "name": "Float", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "zoneID", + "description": "Optional. The ID of a specific zone to filter to. Reports with that zone as their default will be included.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + }, + { + "name": "gameZoneID", + "description": "Optional. The ID of a specific game zone to filter reports to.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": "0" + } + ], + "type": { + "kind": "OBJECT", + "name": "ReportPagination", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "UserData", + "description": "The user data object contains basic information about users and lets you retrieve specific users (or the current user if using the user endpoint).", + "fields": [ + { + "name": "user", + "description": "Obtain a specific user by id.", + "args": [ + { + "name": "id", + "description": "Required. Specify a single user ID to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "User", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "currentUser", + "description": "Obtain the current user (only works with user endpoint).", + "args": [], + "type": { + "kind": "OBJECT", + "name": "User", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "WorldData", + "description": "The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.", + "fields": [ + { + "name": "encounter", + "description": "Obtain a specific encounter by id.", + "args": [ + { + "name": "id", + "description": "Required. Specify a single encounter ID to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Encounter", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "expansion", + "description": "A single expansion obtained by ID.", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single expansion to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Expansion", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "expansions", + "description": "The set of all expansions supported by the site.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Expansion", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "region", + "description": "Obtain a specific region by its ID.", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single region to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Region", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "regions", + "description": "The set of all regions supported by the site.", + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Region", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "server", + "description": "Obtain a specific server either by id or by slug and region.", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single server to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "region", + "description": "Optional. The compact English abbreviation for a specific region (e.g., \"US\"). Use in conjunction with the server slug to retrieve a single server.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "slug", + "description": "Optional. A server slug. Use in conjunction with the server region to retrieve a single server.", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Server", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subregion", + "description": "Obtain a specific subregion by its ID.", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single subregion to retrieve.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Subregion", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zone", + "description": "Obtain a specific zone by its ID.", + "args": [ + { + "name": "id", + "description": "Required. The ID of a specific zone.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "zones", + "description": "Obtain a set of all zones supported by the site.", + "args": [ + { + "name": "expansion_id", + "description": "Optional. The ID of a specific expansion. If omitted, the zones from all expansions will be retrieved.", + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "Zone", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "SCALAR", + "name": "ID", + "description": "The `ID` scalar type represents a unique identifier, often used to\nrefetch an object or as key for a cache. The ID type appears in a JSON\nresponse as a String; however, it is not intended to be human-readable.\nWhen expected as an input type, any string (such as `\"4\"`) or integer\n(such as `4`) input value will be accepted as an ID.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Schema", + "description": "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.", + "fields": [ + { + "name": "types", + "description": "A list of all types supported by this server.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "queryType", + "description": "The type that query operations will be rooted at.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "mutationType", + "description": "If this server supports mutation, the type that mutation operations will be rooted at.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "subscriptionType", + "description": "If this server support subscription, the type that subscription operations will be rooted at.", + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "directives", + "description": "A list of all directives supported by this server.", + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Directive", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Type", + "description": "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name and description, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.", + "fields": [ + { + "name": "kind", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "__TypeKind", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "fields", + "description": null, + "args": [ + { + "name": "includeDeprecated", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Field", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "interfaces", + "description": null, + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "possibleTypes", + "description": null, + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "enumValues", + "description": null, + "args": [ + { + "name": "includeDeprecated", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + }, + "defaultValue": "false" + } + ], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__EnumValue", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "inputFields", + "description": null, + "args": [], + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ofType", + "description": null, + "args": [], + "type": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "__TypeKind", + "description": "An enum describing what kind of type a given `__Type` is.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "SCALAR", + "description": "Indicates this type is a scalar.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "OBJECT", + "description": "Indicates this type is an object. `fields` and `interfaces` are valid fields.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INTERFACE", + "description": "Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UNION", + "description": "Indicates this type is a union. `possibleTypes` is a valid field.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ENUM", + "description": "Indicates this type is an enum. `enumValues` is a valid field.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INPUT_OBJECT", + "description": "Indicates this type is an input object. `inputFields` is a valid field.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LIST", + "description": "Indicates this type is a list. `ofType` is a valid field.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "NON_NULL", + "description": "Indicates this type is a non-null. `ofType` is a valid field.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Field", + "description": "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.", + "fields": [ + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "args", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isDeprecated", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "deprecationReason", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__InputValue", + "description": "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.", + "fields": [ + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "type", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__Type", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "defaultValue", + "description": "A GraphQL-formatted string representing the default value for this input value.", + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__EnumValue", + "description": "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.", + "fields": [ + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isDeprecated", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "deprecationReason", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "__Directive", + "description": "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.", + "fields": [ + { + "name": "name", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "description", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "args", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "OBJECT", + "name": "__InputValue", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "isRepeatable", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "locations", + "description": null, + "args": [], + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "ENUM", + "name": "__DirectiveLocation", + "ofType": null + } + } + } + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "__DirectiveLocation", + "description": "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "QUERY", + "description": "Location adjacent to a query operation.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "MUTATION", + "description": "Location adjacent to a mutation operation.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SUBSCRIPTION", + "description": "Location adjacent to a subscription operation.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FIELD", + "description": "Location adjacent to a field.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FRAGMENT_DEFINITION", + "description": "Location adjacent to a fragment definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FRAGMENT_SPREAD", + "description": "Location adjacent to a fragment spread.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INLINE_FRAGMENT", + "description": "Location adjacent to an inline fragment.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "VARIABLE_DEFINITION", + "description": "Location adjacent to a variable definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SCHEMA", + "description": "Location adjacent to a schema definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "SCALAR", + "description": "Location adjacent to a scalar definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "OBJECT", + "description": "Location adjacent to an object type definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "FIELD_DEFINITION", + "description": "Location adjacent to a field definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ARGUMENT_DEFINITION", + "description": "Location adjacent to an argument definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INTERFACE", + "description": "Location adjacent to an interface definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "UNION", + "description": "Location adjacent to a union definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ENUM", + "description": "Location adjacent to an enum definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ENUM_VALUE", + "description": "Location adjacent to an enum value definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INPUT_OBJECT", + "description": "Location adjacent to an input object type definition.", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "INPUT_FIELD_DEFINITION", + "description": "Location adjacent to an input object field definition.", + "isDeprecated": false, + "deprecationReason": null + } + ], + "possibleTypes": null + }, + { + "kind": "OBJECT", + "name": "ArchonViewModels", + "description": null, + "fields": [ + { + "name": "googleAnalytics", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "game", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "translations", + "description": null, + "args": [ + { + "name": "keys", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "header", + "description": null, + "args": [ + { + "name": "gameSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "headerTitle", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "footer", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "indexPage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gamePage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "contactPage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "aboutPage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "announcementPage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "gameSlugs", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "buildsZonePageSlugs", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "buildsZonePage", + "description": null, + "args": [ + { + "name": "gameSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "rankingsSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "zoneTypeSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "difficultySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "encounterSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "affixesSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "buildsSpecPageSlugs", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "buildsSpecPage", + "description": null, + "args": [ + { + "name": "gameSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "classSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "specSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "zoneTypeSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "categorySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "difficultySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "encounterSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "affixesSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "buildsClassesAndSpecsPage", + "description": null, + "args": [ + { + "name": "gameSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "ability", + "description": null, + "args": [ + { + "name": "id", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "articleCategory", + "description": null, + "args": [ + { + "name": "articleCategorySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "articleCategories", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "articleSlugs", + "description": null, + "args": [ + { + "name": "articleCategorySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "siteName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "article", + "description": null, + "args": [ + { + "name": "articleSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "articleCategorySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "siteName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "cmsNavigation", + "description": null, + "args": [ + { + "name": "currentSlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "pageOfArticlePreviews", + "description": null, + "args": [ + { + "name": "articleCategorySlug", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "pageNumber", + "description": null, + "type": { + "kind": "SCALAR", + "name": "Int", + "ofType": null + }, + "defaultValue": null + }, + { + "name": "siteName", + "description": null, + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "snippets", + "description": null, + "args": [ + { + "name": "snippetSlugs", + "description": null, + "type": { + "kind": "LIST", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "String", + "ofType": null + } + }, + "defaultValue": null + } + ], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "articleIndexPage", + "description": null, + "args": [], + "type": { + "kind": "SCALAR", + "name": "JSON", + "ofType": null + }, + "isDeprecated": false, + "deprecationReason": null + } + ], + "inputFields": null, + "interfaces": [], + "enumValues": null, + "possibleTypes": null + }, + { + "kind": "ENUM", + "name": "SubscriptionStatus", + "description": "The type of Subscription.", + "fields": null, + "inputFields": null, + "interfaces": null, + "enumValues": [ + { + "name": "Silver", + "description": "Silver Tier subscription", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Gold", + "description": "Gold Tier subscription", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "Platinum", + "description": "Platinum Tier subscription", + "isDeprecated": false, + "deprecationReason": null + }, + { + "name": "LegacySilver", + "description": "Legacy Silver Tier subscription", + "isDeprecated": true, + "deprecationReason": "Legacy Silver subscriptions are not available for new users." + }, + { + "name": "LegacyGold", + "description": "Legacy Gold Tier subscription", + "isDeprecated": true, + "deprecationReason": "Legacy Gold subscriptions are not available for new users." + }, + { + "name": "LegacyPlatinum", + "description": "Legacy Platinum Tier subscription", + "isDeprecated": true, + "deprecationReason": "Legacy Platinum subscriptions are not available for new users." + } + ], + "possibleTypes": null + } + ], + "directives": [ + { + "name": "include", + "description": "Directs the executor to include this field or fragment only when the `if` argument is true.", + "locations": [ + "FIELD", + "FRAGMENT_SPREAD", + "INLINE_FRAGMENT" + ], + "args": [ + { + "name": "if", + "description": "Included when true.", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "defaultValue": null + } + ] + }, + { + "name": "skip", + "description": "Directs the executor to skip this field or fragment when the `if` argument is true.", + "locations": [ + "FIELD", + "FRAGMENT_SPREAD", + "INLINE_FRAGMENT" + ], + "args": [ + { + "name": "if", + "description": "Skipped when true.", + "type": { + "kind": "NON_NULL", + "name": null, + "ofType": { + "kind": "SCALAR", + "name": "Boolean", + "ofType": null + } + }, + "defaultValue": null + } + ] + }, + { + "name": "deprecated", + "description": "Marks an element of a GraphQL schema as no longer supported.", + "locations": [ + "FIELD_DEFINITION", + "ENUM_VALUE" + ], + "args": [ + { + "name": "reason", + "description": "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax (as specified by [CommonMark](https:\/\/commonmark.org\/).", + "type": { + "kind": "SCALAR", + "name": "String", + "ofType": null + }, + "defaultValue": "\"No longer supported\"" + } + ] + } + ] + } + } +} From 3d4c456d6e4af328a5abce2336ccdb348e34d430 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Mon, 22 Jan 2024 00:41:16 -0700 Subject: [PATCH 2/7] clean up files --- main.py | 128 +++-------------------------------------------- wcl/interface.py | 2 - 2 files changed, 7 insertions(+), 123 deletions(-) diff --git a/main.py b/main.py index a277dd6..a89de85 100644 --- a/main.py +++ b/main.py @@ -1,100 +1,5 @@ -# def tier_guard_analysis( info ): -# reportCode = info.get( 'reportCode' ) -# startTime = info.get( 'startTime' ) -# endTime = info.get( 'endTime' ) -# id = info.get( 'id' ) -# charred_dreams = wcl.getEvents( -# reportCode, -# None, -# { -# 'dataType': 'DamageDone', -# 'abilityID': 425299, -# 'startTime': startTime, -# 'endTime': endTime, -# 'useAbilityIDs': 'true', -# 'sourceID': id -# } -# ) -# shadowflame_wreathe = wcl.getEvents( -# reportCode, -# None, -# { -# 'dataType': 'DamageDone', -# 'abilityID': 406764, -# 'startTime': startTime, -# 'endTime': endTime, -# 'useAbilityIDs': 'true', -# 'sourceID': id -# } -# ) -# celestial_brew = wcl.getEvents( -# reportCode, -# None, -# { -# 'dataType': 'Buffs', -# 'abilityID': 425965, -# 'startTime': startTime, -# 'endTime': endTime, -# 'useAbilityIDs': 'true', -# 'sourceID': id -# } -# ) -# charred_dreams_data = list( chain.from_iterable( charred_dreams.data ) ) -# shadowflame_wreathe_data = list( chain.from_iterable( shadowflame_wreathe.data ) ) -# celestial_brew_data = list( chain.from_iterable( celestial_brew.data ) ) - -# # flatten data -# # healing_data = list(chain.from_iterable(healing.data)) -# # buffs_data = list(chain.from_iterable(buffs.data)) -# # casts_data = list(chain.from_iterable(casts.data)) -# # damage_taken_data = list(chain.from_iterable(damage_taken.data)) - -# # merge data and sort by timestamp -# data = sorted( -# # healing_data + buffs_data + casts_data + damage_taken_data, -# # healing_data, -# charred_dreams_data + celestial_brew_data + shadowflame_wreathe_data, # + elementium_pocket_anvil_data, -# key=lambda s: (s.get('timestamp'))) - -# acc = 0 -# amt = 0 -# ct = 0 -# for k in data: -# spell_id = k.get( 'abilityGameID' ) -# if spell_id == 425299: -# amt += k.get( 'unmitigatedAmount' ) -# # print(k.get('sourceID'), k.get('targetID')) -# # amt += k.get('amount') -# # if spell_id == 425965 and k.get('type') == 'removebuff': -# # print(k) -# # amt = 0 -# if spell_id == 425965 and k.get( 'type' ) == 'applybuff': -# absorb = k.get( 'absorb' ) -# reverse_crit_vers = absorb / ( 1 + 0.8 * 0.4007 ) / ( 1 + 0.2165 ) -# acc += absorb -# ct += 1 -# # print('Absorb:', k.get('absorb')) -# # print('Damage Dealt since last:', amt) -# # print('Difference:', amt - absorb) -# # print('Reverse crit and vers:', reverse_crit_vers) -# # if amt > 0: -# # print('Ratio:', absorb / amt) -# # print('Inverse ratio:', amt / absorb) -# # print('Reverse Ratio:', reverse_crit_vers / amt) -# # print() -# amt = 0 - -# print( acc / ct ) - -# # runReports(tier_proc_analysis) -# # runReports(tier_guard_analysis) - -# # wcl.Request(wcl.PointsSpent()) -# # wcl.getPointsSpent() - -# import json - import analyzers +import wcl # analyzers.ignited_essence.ignited_essence( [ # 'xrfcz1d34vjJ2LqM', @@ -102,12 +7,12 @@ # 'vr1RPbDWJ9YakM8j', # ] ) -analyzers.press_the_advantage.bug_detection( [ - 'xrfcz1d34vjJ2LqM', - 'CXgx2FPYybAjvn1H', - 'ny4h6wmpKVbHZq7Q', - 'gbD8RQrZK7vj1hWF' -] ) +# analyzers.press_the_advantage.bug_detection( [ +# 'xrfcz1d34vjJ2LqM', +# 'CXgx2FPYybAjvn1H', +# 'ny4h6wmpKVbHZq7Q', +# 'gbD8RQrZK7vj1hWF' +# ] ) # analyzers.t31_brew.proc( [ # 'bkrPDQ1ZtTGRphWn', @@ -154,25 +59,6 @@ # ] # ) -import wcl - -# t = wcl.GQL_Object( {'asdf': 'fdsa'}, {'jkl': 'lkj'} ) -# print(t) - -# class Test: -# asdf = 'jkl' - -# d = { -# '1': Test -# } - -# for v in d.values(): -# print(isinstance(Test(), v)) - -# u = wcl.GQL_Test1( {}, {} ).tree() -# v = wcl.GQL_Test2( {}, {} ).tree() -# print(u) -# print(v) class GQL_OBJECT: active = [] name = 'GQL_OBJECT' diff --git a/wcl/interface.py b/wcl/interface.py index d790e8d..693de80 100644 --- a/wcl/interface.py +++ b/wcl/interface.py @@ -1,8 +1,6 @@ import json from copy import deepcopy -from numpy import char - from . import query, request def getFights( params ): From f88a36f1fcd286cb6ac1dc7eb3f2c280c815070e Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Mon, 22 Jan 2024 03:51:33 -0700 Subject: [PATCH 3/7] this system works but isn't reasonable to generate code for --- main.py | 140 +++++++++++++++++++++++++++++------- wcl/query.py | 198 ++++++++++++++++++++------------------------------- 2 files changed, 191 insertions(+), 147 deletions(-) diff --git a/main.py b/main.py index a89de85..3ffca9c 100644 --- a/main.py +++ b/main.py @@ -1,3 +1,4 @@ +from os import truncate import analyzers import wcl @@ -60,46 +61,135 @@ # ) class GQL_OBJECT: - active = [] name = 'GQL_OBJECT' - def __init__( self, child_class_name = '', child_str = '' ): - self.child_class_name = child_class_name - self.child_str = child_str + args = {} + fields = {} + params = {} + def __init__( self ): + # object metadata configuration self.parent = self.__class__.__mro__[1] - self.children = list(self.__class__.__subclasses__()) + # defer evaluation until runtime so classes are defined + self.args = { + key: eval( value ) + for key, value in self.args.items() + # if print(key, value)or True + } + self.fields = { + key: eval( value ) + for key, value in self.fields.items() + } - def __str__( self ): - children = [ - self.child_str if child.name == self.child_class_name else str( child.name ) - for child in self.children - if child.name in self.active + def init( self, params ): + def ancestor_list( obj ): + parent = obj.parent() + if parent.name != 'GQL_OBJECT': + yield from ancestor_list( parent ) + yield obj + + self.params = params + self.ancestors = list( ancestor_list( self ) ) + self.ancestor_names = [ ancestor.name for ancestor in self.ancestors ] + for ancestor in self.ancestors[:-1]: + ancestor.init( self.params ) + + def str( self, ancestor_names ): + assert self.params, 'Initialization incomplete' + args = [ + f'{argk}: {argv}' + for argk, argv_t in self.args.items() + if ( argv := self.params.get( argk ) ) + if isinstance( argv, argv_t ) or argv_t.is_compatible( argv ) + ] + fields = [ + f'{argk}' + for argk in self.fields.keys() + if argk in self.params.keys() and argk not in ancestor_names ] - ret = self.name - if len( children ): - ret += '{' + ', '.join( children ) + '}' - if self.parent.__name__ != 'GQL_OBJECT': - return str( self.parent( self.name, ret ) ) - return '{' + ret + '}' + args_str = f'({", ".join(args)})' if args else '' + fields_str = f'{", ".join(fields)}' + return self.name, args_str, fields_str + + def __str__( self ): + string = '' + for ancestor in reversed( self.ancestors ): + ancestor_name, ancestor_args_str, ancestor_fields_str = ancestor.str( self.ancestor_names ) + fields_str = ancestor_fields_str + ( ', ' if ancestor_fields_str else '' ) + string + fields_str = f'{{{fields_str}}}' if ancestor_fields_str or string else fields_str + string = f'{ancestor_name}{ancestor_args_str}{fields_str}' + return f'{{{string}}}' class query( GQL_OBJECT ): name = 'query' - active = [ 'report' ] - report = lambda *args, **kwargs: eval( '_QrsNKiY_WLpJ6Iu_report' )( *args, **kwargs ) + args = {} + fields = { + 'report': '_QrsNKiY_WLpJ6Iu_report', + } class _QrsNKiY_WLpJ6Iu_report( query, GQL_OBJECT ): name = 'report' - active = [ 'code', 'events' ] - code = lambda *args, **kwargs: eval( '_MqAkvZzWS6CGIGj_code' )( *args, **kwargs ) - events = lambda *args, **kwargs: eval( '_GZ3efcSVmPvraRn_events' )( *args, **kwargs ) - -class _MqAkvZzWS6CGIGj_code( _QrsNKiY_WLpJ6Iu_report, GQL_OBJECT ): - name = 'code' + args = { + 'code': 'GQL_String', + } + fields = { + 'code': 'GQL_String', + 'events': '_GZ3efcSVmPvraRn_events', + } class _GZ3efcSVmPvraRn_events( _QrsNKiY_WLpJ6Iu_report, GQL_OBJECT ): name = 'events' + args = { + 'startTime': 'GQL_Int', + 'endTime': 'GQL_Int', + } + fields = {} + +class GQL_T: + compatible_list = [] + value = None + def __init__( self, value ): + self.value = value + @classmethod + def is_compatible( cls, obj ): + if type(obj) in cls.compatible_list: + return True + return False + +class GQL_String( GQL_T ): + compatible_list = [ str ] + def __str__( self ): + return f'"{self.value}"' + +class GQL_Int( GQL_T ): + compatible_list = [ int ] + def __str__( self ): + return str(self.value) + + +def query_lookup( *args ): + current = eval( f'{args[0]}()' ) + for arg in args[1:]: + current = current.fields[ arg ]() + return current + +params = { + 'code': 'asdfjkl', + 'startTime': 100, + 'endTime': 200, + 'report': 'asdf', + 'events': True +} + +# print( query_lookup( 'query', 'report', 'events' )( params ) ) +# print( query().report().events() ) +# print( query().report() ) +q = query_lookup( 'query', 'report', 'events' ) +q.init( params ) +print( q ) -print( query().report().events() ) +# print( query_lookup( 'query', 'report', 'events' )() ) +# print( query_lookup( 'query', 'report' )() ) +# print( query_lookup( 'query' )() ) import unicodedata from keyword import iskeyword diff --git a/wcl/query.py b/wcl/query.py index cf30b73..94c131d 100644 --- a/wcl/query.py +++ b/wcl/query.py @@ -431,6 +431,15 @@ def __str__( self ): if entry.get( 'kind' ) == 'ENUM': enums.append( entry ) + names = [ + e.get('name') + for e in objects + ] + # print( names ) + # print( len(names)) + # print(len(set(names))) + print(json.dumps(objects, indent=2)) + # print( 'from .query import GQL_ENUM, GQL_OBJECT') # for enum in enums: @@ -459,125 +468,70 @@ def __str__( self ): # print( ' ]') - def find_type( obj ): - base = obj.get( 'type' ) or obj.get( 'ofType' ) - if base[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - return base[ 'name' ] - return find_type( base ) - - def objects_with_matching_type( type_name ): - rets = [] - for obj in objects: - fields = obj.get( 'fields', [] ) - for field in fields: - if type_name == find_type( field ) and field.get( 'args' ) != []: - rets.append( field ) - return rets - - def object_name_from_type( type_obj ): - if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' - if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: - type_obj = type_obj[ 'ofType' ] - return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' - - def object_name( type_obj ): - if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - return f'{type_obj[ "name" ]}' - if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: - type_obj = type_obj[ 'ofType' ] - return f'{type_obj[ "name" ]}' - - def process_arg_or_field( entry ): - return { - 'TYPE': object_name_from_type( entry[ 'type' ] ), - 'IS_LIST': entry[ 'type' ][ 'kind' ] == 'LIST', - 'DESCRIPTION': entry[ 'description' ] - } - - def objects_have_matching_type( a, b ): - matches = [ - object_name( field[ 'type' ] ) == a[ 'name' ] - for field in b[ 'fields' ] - ] - return b[ 'fields' ][ matches.index( True ) ] if True in matches else False - - objects = [ - { - 'TYPE_NAME': base[ 'name' ], - 'NAME': variant_obj[ 'name' ], - 'VARIANT_COUNT': max( 1, len( objects_with_matching_type( base[ 'name' ] ) ) ), - 'PARENT': None, - 'ARGS': { - arg[ 'name' ]: process_arg_or_field( arg ) - for arg in variant_obj[ 'args' ] - }, - 'FIELDS': { - field[ 'name' ]: process_arg_or_field( field ) - for field in base[ 'fields' ] - }, - 'DESCRIPTION': [ - description - for description in [ base[ 'description' ], variant_obj[ 'description' ] ] - if description - ] - } - for base, variant in product( objects, objects ) - if base[ 'name' ][ :2 ] != '__' - if ( variant_obj := objects_have_matching_type( base, variant ) ) - ] - - # print(json.dumps(objects, indent=2)) - # objnames = { - # obj.get('NAME') - # for obj in objects - # } - objnames = set() - # print( len( objnames ), len( objects ) ) - for u, v in product (objects, objects): - if u.get('NAME') == v.get('NAME') and u != v: - print() - print(u.get('NAME'), u.get('TYPE_NAME')) - print(v.get('NAME'), v.get('TYPE_NAME')) - - # for obj in objects: - # type_name = obj[ 'name' ] - # if type_name != 'Report': - # continue - # descr = obj[ 'description' ] - # fields = [] - # for it in objects: - # candidates = it.get( 'fields', [] ) - # for candidate in candidates: - # if find_type( candidate ) == type_name: - # fields.append( candidate ) - # for k in fields: - # print( find_type( k ) ) - # print(k) - # print() - # if descr is not None: - # print( f'# {descr}') - # print( f'class GQL_OBJECT_{type_name}( GQL_OBJECT ):' ) - # print( ' def __init__( self, args, fields ):' ) - # print( ' self.arg_types = {' ) - # print( ' }' ) - # print( ' self.field_types = {' ) - # print( ' }' ) - # print( f' self.name = {type_name}' ) - # # for e, v in obj.items(): - # # if e == 'fields': - # # q = set() - # # for x in v: - # # print( x.get('name')) - # # print( x.get('type')) - # # for q in x.get( 'args' ): - # # for w, e in q.items(): - # # print( w, e) - # # print( x.get('args')) - # # for o, p in x.items(): - # # q.add( o ) - # # print( f'{e}: {v}') - # for e in obj.keys(): - # t.add( e ) - - # # print(t) + # def find_type( obj ): + # base = obj.get( 'type' ) or obj.get( 'ofType' ) + # if base[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + # return base[ 'name' ] + # return find_type( base ) + + # def objects_with_matching_type( type_name ): + # rets = [] + # for obj in objects: + # fields = obj.get( 'fields', [] ) + # for field in fields: + # if type_name == find_type( field ) and field.get( 'args' ) != []: + # rets.append( field ) + # return rets + + # def object_name_from_type( type_obj ): + # if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + # return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' + # if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: + # type_obj = type_obj[ 'ofType' ] + # return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' + + # def object_name( type_obj ): + # if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: + # return f'{type_obj[ "name" ]}' + # if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: + # type_obj = type_obj[ 'ofType' ] + # return f'{type_obj[ "name" ]}' + + # def process_arg_or_field( entry ): + # return { + # 'TYPE': object_name_from_type( entry[ 'type' ] ), + # 'IS_LIST': entry[ 'type' ][ 'kind' ] == 'LIST', + # 'DESCRIPTION': entry[ 'description' ] + # } + + # def objects_have_matching_type( a, b ): + # matches = [ + # object_name( field[ 'type' ] ) == a[ 'name' ] + # for field in b[ 'fields' ] + # ] + # return b[ 'fields' ][ matches.index( True ) ] if True in matches else False + + # objects = [ + # { + # 'TYPE_NAME': base[ 'name' ], + # 'NAME': variant_obj[ 'name' ], + # 'VARIANT_COUNT': max( 1, len( objects_with_matching_type( base[ 'name' ] ) ) ), + # 'PARENT': None, + # 'ARGS': { + # arg[ 'name' ]: process_arg_or_field( arg ) + # for arg in variant_obj[ 'args' ] + # }, + # 'FIELDS': { + # field[ 'name' ]: process_arg_or_field( field ) + # for field in base[ 'fields' ] + # }, + # 'DESCRIPTION': [ + # description + # for description in [ base[ 'description' ], variant_obj[ 'description' ] ] + # if description + # ] + # } + # for base, variant in product( objects, objects ) + # if base[ 'name' ][ :2 ] != '__' + # if ( variant_obj := objects_have_matching_type( base, variant ) ) + # ] From f6f2b31401f1461af62660912e41fdf5de7c0793 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Thu, 1 Feb 2024 05:13:21 -0700 Subject: [PATCH 4/7] nearly to a working solution --- main.py | 121 ++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 79 insertions(+), 42 deletions(-) diff --git a/main.py b/main.py index 3ffca9c..b9a1872 100644 --- a/main.py +++ b/main.py @@ -62,23 +62,40 @@ class GQL_OBJECT: name = 'GQL_OBJECT' - args = {} fields = {} params = {} - def __init__( self ): - # object metadata configuration - self.parent = self.__class__.__mro__[1] + def __init__( self, ancestry=None ): # defer evaluation until runtime so classes are defined - self.args = { - key: eval( value ) - for key, value in self.args.items() - # if print(key, value)or True - } - self.fields = { - key: eval( value ) - for key, value in self.fields.items() - } + self.fields = [ + field | { + 'type': eval( field[ 'type' ] ), + 'args': [ + { argk: eval( argv_t ) for argk, argv_t in arg.items() } + for arg in field[ 'args' ] + ] + } + for field in self.fields + ] + + if ancestry: + self.ancestors = [ eval( f'GQL_Object_{ancestry[0]}' )() ] + +""" +currently thinking about initializing everything backwards and then i don't need evals +deepest nodes first, then move outward +or some smarter init strategy where you init everything without obj deps +then check if you have resolved any deps for new objs +repeat until objs exhausted + +this allows for incomplete initialization of gql objects, as all information +is initialized prior to instantiation of any gql objects + +still need a way to ascertain parent in the gql tree, but a path must be provided +to disambaguate requests from each other, or it would be unclear which path to follow +can use that to determine ancestry of objects, thus the correct names for objects and +use the available args +""" def init( self, params ): def ancestor_list( obj ): @@ -95,20 +112,27 @@ def ancestor_list( obj ): def str( self, ancestor_names ): assert self.params, 'Initialization incomplete' + args_from_parent = [] + name_from_parent = self.name + for field in self.parent().fields: + if isinstance( self, field[ 'type' ] ): + args_from_parent = field[ 'args' ] + name_from_parent = field[ 'name' ] args = [ f'{argk}: {argv}' - for argk, argv_t in self.args.items() + for d in args_from_parent + for argk, argv_t in d.items() if ( argv := self.params.get( argk ) ) if isinstance( argv, argv_t ) or argv_t.is_compatible( argv ) ] fields = [ - f'{argk}' - for argk in self.fields.keys() - if argk in self.params.keys() and argk not in ancestor_names + f'{argk[ "name" ]}' + for argk in self.fields + if argk[ 'name' ] in self.params.keys() and argk[ 'name' ] not in ancestor_names ] args_str = f'({", ".join(args)})' if args else '' fields_str = f'{", ".join(fields)}' - return self.name, args_str, fields_str + return name_from_parent, args_str, fields_str def __str__( self ): string = '' @@ -119,30 +143,39 @@ def __str__( self ): string = f'{ancestor_name}{ancestor_args_str}{fields_str}' return f'{{{string}}}' -class query( GQL_OBJECT ): +class GQL_Object_Query( GQL_OBJECT ): name = 'query' - args = {} - fields = { - 'report': '_QrsNKiY_WLpJ6Iu_report', - } - -class _QrsNKiY_WLpJ6Iu_report( query, GQL_OBJECT ): + fields = [ + { + 'name': 'report', + 'type': 'GQL_Object_Report', + 'args': [ + { 'code': 'GQL_String' }, + ] + }, + ] + +class GQL_Object_Report( GQL_Object_Query, GQL_OBJECT ): name = 'report' - args = { - 'code': 'GQL_String', - } - fields = { - 'code': 'GQL_String', - 'events': '_GZ3efcSVmPvraRn_events', - } - -class _GZ3efcSVmPvraRn_events( _QrsNKiY_WLpJ6Iu_report, GQL_OBJECT ): + fields = [ + { + 'name': 'code', + 'type': 'GQL_String', + 'args': [] + }, + { + 'name': 'events', + 'type': 'GQL_Object_Events', + 'args': [ + { 'startTime': 'GQL_Int' }, + { 'endTime': 'GQL_Int' }, + ] + } + ] + +class GQL_Object_Events( GQL_Object_Report, GQL_OBJECT ): name = 'events' - args = { - 'startTime': 'GQL_Int', - 'endTime': 'GQL_Int', - } - fields = {} + fields = [] class GQL_T: compatible_list = [] @@ -167,9 +200,13 @@ def __str__( self ): def query_lookup( *args ): - current = eval( f'{args[0]}()' ) + current = eval( f'GQL_Object_{args[0]}()' ) for arg in args[1:]: - current = current.fields[ arg ]() + n = lambda: None + for field in current.fields: + if field[ 'name' ] == arg: + n = field[ 'type' ] + current = n() return current params = { @@ -183,7 +220,7 @@ def query_lookup( *args ): # print( query_lookup( 'query', 'report', 'events' )( params ) ) # print( query().report().events() ) # print( query().report() ) -q = query_lookup( 'query', 'report', 'events' ) +q = query_lookup( 'Query', 'report', 'events' ) q.init( params ) print( q ) From f104b9ba5fa06c4a11b196700f95623644d3c5e9 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Mon, 26 Feb 2024 00:23:43 -0700 Subject: [PATCH 5/7] partially working new type system --- .gitignore | 9 +- main.py | 503 ++++++++++---------- wcl/query.py | 1017 ++++++++++++++++++++-------------------- wcl/query_generated.py | 89 ---- wcl/types/enum.py | 238 ++++++++++ wcl/types/object.py | 155 ++++++ wcl/types/scalar.py | 32 ++ 7 files changed, 1192 insertions(+), 851 deletions(-) delete mode 100644 wcl/query_generated.py create mode 100644 wcl/types/enum.py create mode 100644 wcl/types/object.py create mode 100644 wcl/types/scalar.py diff --git a/.gitignore b/.gitignore index 9548b69..6643265 100644 --- a/.gitignore +++ b/.gitignore @@ -1,13 +1,12 @@ # emacs .\#* +# direnv +.envrc + # python +venv __pycache__ -bin -lib -lib64 -pyvenv.cfg -share # credentials credentials diff --git a/main.py b/main.py index b9a1872..b046b49 100644 --- a/main.py +++ b/main.py @@ -60,27 +60,6 @@ # ] # ) -class GQL_OBJECT: - name = 'GQL_OBJECT' - fields = {} - - params = {} - def __init__( self, ancestry=None ): - # defer evaluation until runtime so classes are defined - self.fields = [ - field | { - 'type': eval( field[ 'type' ] ), - 'args': [ - { argk: eval( argv_t ) for argk, argv_t in arg.items() } - for arg in field[ 'args' ] - ] - } - for field in self.fields - ] - - if ancestry: - self.ancestors = [ eval( f'GQL_Object_{ancestry[0]}' )() ] - """ currently thinking about initializing everything backwards and then i don't need evals deepest nodes first, then move outward @@ -97,230 +76,258 @@ def __init__( self, ancestry=None ): use the available args """ - def init( self, params ): - def ancestor_list( obj ): - parent = obj.parent() - if parent.name != 'GQL_OBJECT': - yield from ancestor_list( parent ) - yield obj - - self.params = params - self.ancestors = list( ancestor_list( self ) ) - self.ancestor_names = [ ancestor.name for ancestor in self.ancestors ] - for ancestor in self.ancestors[:-1]: - ancestor.init( self.params ) - - def str( self, ancestor_names ): - assert self.params, 'Initialization incomplete' - args_from_parent = [] - name_from_parent = self.name - for field in self.parent().fields: - if isinstance( self, field[ 'type' ] ): - args_from_parent = field[ 'args' ] - name_from_parent = field[ 'name' ] - args = [ - f'{argk}: {argv}' - for d in args_from_parent - for argk, argv_t in d.items() - if ( argv := self.params.get( argk ) ) - if isinstance( argv, argv_t ) or argv_t.is_compatible( argv ) - ] - fields = [ - f'{argk[ "name" ]}' - for argk in self.fields - if argk[ 'name' ] in self.params.keys() and argk[ 'name' ] not in ancestor_names - ] - args_str = f'({", ".join(args)})' if args else '' - fields_str = f'{", ".join(fields)}' - return name_from_parent, args_str, fields_str - - def __str__( self ): - string = '' - for ancestor in reversed( self.ancestors ): - ancestor_name, ancestor_args_str, ancestor_fields_str = ancestor.str( self.ancestor_names ) - fields_str = ancestor_fields_str + ( ', ' if ancestor_fields_str else '' ) + string - fields_str = f'{{{fields_str}}}' if ancestor_fields_str or string else fields_str - string = f'{ancestor_name}{ancestor_args_str}{fields_str}' - return f'{{{string}}}' - -class GQL_Object_Query( GQL_OBJECT ): - name = 'query' - fields = [ - { - 'name': 'report', - 'type': 'GQL_Object_Report', - 'args': [ - { 'code': 'GQL_String' }, - ] - }, - ] - -class GQL_Object_Report( GQL_Object_Query, GQL_OBJECT ): - name = 'report' - fields = [ - { - 'name': 'code', - 'type': 'GQL_String', - 'args': [] - }, - { - 'name': 'events', - 'type': 'GQL_Object_Events', - 'args': [ - { 'startTime': 'GQL_Int' }, - { 'endTime': 'GQL_Int' }, - ] - } - ] - -class GQL_Object_Events( GQL_Object_Report, GQL_OBJECT ): - name = 'events' - fields = [] - -class GQL_T: - compatible_list = [] - value = None - def __init__( self, value ): - self.value = value - @classmethod - def is_compatible( cls, obj ): - if type(obj) in cls.compatible_list: - return True - return False - -class GQL_String( GQL_T ): - compatible_list = [ str ] - def __str__( self ): - return f'"{self.value}"' - -class GQL_Int( GQL_T ): - compatible_list = [ int ] - def __str__( self ): - return str(self.value) - - -def query_lookup( *args ): - current = eval( f'GQL_Object_{args[0]}()' ) - for arg in args[1:]: - n = lambda: None - for field in current.fields: - if field[ 'name' ] == arg: - n = field[ 'type' ] - current = n() - return current - -params = { - 'code': 'asdfjkl', - 'startTime': 100, - 'endTime': 200, - 'report': 'asdf', - 'events': True -} - -# print( query_lookup( 'query', 'report', 'events' )( params ) ) -# print( query().report().events() ) -# print( query().report() ) -q = query_lookup( 'Query', 'report', 'events' ) -q.init( params ) -print( q ) - -# print( query_lookup( 'query', 'report', 'events' )() ) -# print( query_lookup( 'query', 'report' )() ) -# print( query_lookup( 'query' )() ) - -import unicodedata -from keyword import iskeyword -import random -import sys - -def is_allowed_unicode_char( c, position ): - # Other_ID_Start and Other_ID_Continue are from the following webpage with the matching category (?) name - # https://www.unicode.org/Public/15.0.0/ucd/PropList.txt - Other_ID_Start = { '\u1885', '\u1886', '\u2118', '\u212E', '\u309B', '\u309C' } - Other_ID_Continue = { '\u00B7', '\u0387', '\u1369', '\u1370', '\u1371', '\u19DA' } - # id_start and id_continue category_codes are defined from the following webpage: - # https://docs.python.org/3/reference/lexical_analysis.html#identifiers - id_start_category_codes = { 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' } - id_continue_category_codes = id_start_category_codes | { 'Mn', 'Mc', 'Nd', 'Pc' } - # id_start and id_continue singletons are defined from the following webpage: - # https://docs.python.org/3/reference/lexical_analysis.html#identifiers - id_start_singletons = { '_' } | Other_ID_Start - id_continue_singletons = id_start_singletons | Other_ID_Continue - - if unicodedata.category( c ) in id_start_category_codes or c in id_start_singletons: - return c - if position > 0 and ( unicodedata.category( c ) in id_continue_category_codes or c in id_continue_singletons ): - return c - -def generate_unicode_identifier( length = 16 ): - # This implementation is correct, but returned strings are: - # - Unmanageably unreadable - # - Not reliably generated due to too small of a character set (to improve readability) - # - Requires too much pregeneration (to avoid unreliable generation) - - # This does not generate all possible unicode identifiers, as I did not find - # a way to find all characters that NFKC normalize to a valid character. - def generate_chr(attempt = 0): - c = chr( random.randrange( sys.maxunicode + 1 ) ) - if is_allowed_unicode_char( c, 0 ): - return c - return generate_chr( attempt + 1 ) - - candidate_str = ''.join( [ - c - for _ in range( length ) - if ( c := generate_chr() ) - ] ) - - if not iskeyword( candidate_str ): - return candidate_str - return generate_unicode_identifier( length = length ) - -def generate_ascii_identifier( length = 16 ): - # Only a small subset of valid Python 3 Identifiers, but: - # - Highly readable - # - Still millions of combinations - # - More trivial to generate - MIN_ASCII = 33 - MAX_ASCII = 126 - - def generate_chr( position, attempts = 0 ): - character = chr( random.randrange( MIN_ASCII, MAX_ASCII ) ) - if is_allowed_unicode_char( character, position ): - return character - return generate_chr( position, attempts + 1) - - candidate_str = '_' + ''.join( [ - generate_chr( pos ) - for pos in range( length - 1 ) - ] ) - - if not iskeyword( candidate_str ) and candidate_str.isidentifier(): - return candidate_str - return generate_ascii_identifier( length = length ) - - -# for k in range( 5 ): -# ident = generate_ascii_identifier() -# print(ident, len(ident)) - - - -# PROBLEM: -# - nested classes are gross -# - having no nested classes with their actual names results in namespace clashes -# SOLUTION: -# a) -# - queries with no parents get their actual name for their object name -# - queries with parents get an internal name, and are added to the parent with their real name via `__subclasses__()` and `setattr(...)` -# b) -# - infrastructure exists for type hoisting, but it may not be useful in this situation - -# print(C()) -# print(C().D()) - -# print( A() ) -# for q in A().children: -# print( q(), q().parent() ) -# for u in q().children: -# print( u(), u().parent() ) +""" +1. each object uses the canonical GQL typename as its name +2. each object contains two sets of references: args and fields +2. each reference contains GQL typename, local aliased name and metadata +""" + +# class GQL_OBJECT: +# name = 'GQL_OBJECT' +# fields = {} + +# params = {} + +# def __init__( self, ancestry=None ): +# # defer evaluation until runtime so classes are defined +# self.fields = [ +# field | { +# 'type': eval( field[ 'type' ] ), +# 'args': [ +# { argk: eval( argv_t ) for argk, argv_t in arg.items() } +# for arg in field[ 'args' ] +# ] +# } +# for field in self.fields +# ] + +# if ancestry: +# self.ancestors = [ eval( f'GQL_Object_{ancestry[0]}' )() ] + +# def init( self, params ): +# def ancestor_list( obj ): +# parent = obj.parent() +# if parent.name != 'GQL_OBJECT': +# yield from ancestor_list( parent ) +# yield obj + +# self.params = params +# self.ancestors = list( ancestor_list( self ) ) +# self.ancestor_names = [ ancestor.name for ancestor in self.ancestors ] +# for ancestor in self.ancestors[:-1]: +# ancestor.init( self.params ) + +# def str( self, ancestor_names ): +# assert self.params, 'Initialization incomplete' +# args_from_parent = [] +# name_from_parent = self.name +# for field in self.parent().fields: +# if isinstance( self, field[ 'type' ] ): +# args_from_parent = field[ 'args' ] +# name_from_parent = field[ 'name' ] +# args = [ +# f'{argk}: {argv}' +# for d in args_from_parent +# for argk, argv_t in d.items() +# if ( argv := self.params.get( argk ) ) +# if isinstance( argv, argv_t ) or argv_t.is_compatible( argv ) +# ] +# fields = [ +# f'{argk[ "name" ]}' +# for argk in self.fields +# if argk[ 'name' ] in self.params.keys() and argk[ 'name' ] not in ancestor_names +# ] +# args_str = f'({", ".join(args)})' if args else '' +# fields_str = f'{", ".join(fields)}' +# return name_from_parent, args_str, fields_str + +# def __str__( self ): +# string = '' +# for ancestor in reversed( self.ancestors ): +# ancestor_name, ancestor_args_str, ancestor_fields_str = ancestor.str( self.ancestor_names ) +# fields_str = ancestor_fields_str + ( ', ' if ancestor_fields_str else '' ) + string +# fields_str = f'{{{fields_str}}}' if ancestor_fields_str or string else fields_str +# string = f'{ancestor_name}{ancestor_args_str}{fields_str}' +# return f'{{{string}}}' + +# class GQL_Object_Query( GQL_OBJECT ): +# name = 'query' +# fields = [ +# { +# 'name': 'report', +# 'type': 'GQL_Object_Report', +# 'args': [ +# { 'code': 'GQL_String' }, +# ] +# }, +# ] + +# class GQL_Object_Report( GQL_Object_Query, GQL_OBJECT ): +# name = 'report' +# fields = [ +# { +# 'name': 'code', +# 'type': 'GQL_String', +# 'args': [] +# }, +# { +# 'name': 'events', +# 'type': 'GQL_Object_Events', +# 'args': [ +# { 'startTime': 'GQL_Int' }, +# { 'endTime': 'GQL_Int' }, +# ] +# } +# ] + +# class GQL_Object_Events( GQL_Object_Report, GQL_OBJECT ): +# name = 'events' +# fields = [] + +# class GQL_T: +# compatible_list = [] +# value = None +# def __init__( self, value ): +# self.value = value +# @classmethod +# def is_compatible( cls, obj ): +# if type(obj) in cls.compatible_list: +# return True +# return False + +# class GQL_String( GQL_T ): +# compatible_list = [ str ] +# def __str__( self ): +# return f'"{self.value}"' + +# class GQL_Int( GQL_T ): +# compatible_list = [ int ] +# def __str__( self ): +# return str(self.value) + + +# def query_lookup( *args ): +# current = eval( f'GQL_Object_{args[0]}()' ) +# for arg in args[1:]: +# n = lambda: None +# for field in current.fields: +# if field[ 'name' ] == arg: +# n = field[ 'type' ] +# current = n() +# return current + +# params = { +# 'code': 'asdfjkl', +# 'startTime': 100, +# 'endTime': 200, +# 'report': 'asdf', +# 'events': True +# } + +# # print( query_lookup( 'query', 'report', 'events' )( params ) ) +# # print( query().report().events() ) +# # print( query().report() ) +# q = query_lookup( 'Query', 'report', 'events' ) +# q.init( params ) +# print( q ) + +# # print( query_lookup( 'query', 'report', 'events' )() ) +# # print( query_lookup( 'query', 'report' )() ) +# # print( query_lookup( 'query' )() ) + +# import unicodedata +# from keyword import iskeyword +# import random +# import sys + +# def is_allowed_unicode_char( c, position ): +# # Other_ID_Start and Other_ID_Continue are from the following webpage with the matching category (?) name +# # https://www.unicode.org/Public/15.0.0/ucd/PropList.txt +# Other_ID_Start = { '\u1885', '\u1886', '\u2118', '\u212E', '\u309B', '\u309C' } +# Other_ID_Continue = { '\u00B7', '\u0387', '\u1369', '\u1370', '\u1371', '\u19DA' } +# # id_start and id_continue category_codes are defined from the following webpage: +# # https://docs.python.org/3/reference/lexical_analysis.html#identifiers +# id_start_category_codes = { 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' } +# id_continue_category_codes = id_start_category_codes | { 'Mn', 'Mc', 'Nd', 'Pc' } +# # id_start and id_continue singletons are defined from the following webpage: +# # https://docs.python.org/3/reference/lexical_analysis.html#identifiers +# id_start_singletons = { '_' } | Other_ID_Start +# id_continue_singletons = id_start_singletons | Other_ID_Continue + +# if unicodedata.category( c ) in id_start_category_codes or c in id_start_singletons: +# return c +# if position > 0 and ( unicodedata.category( c ) in id_continue_category_codes or c in id_continue_singletons ): +# return c + +# def generate_unicode_identifier( length = 16 ): +# # This implementation is correct, but returned strings are: +# # - Unmanageably unreadable +# # - Not reliably generated due to too small of a character set (to improve readability) +# # - Requires too much pregeneration (to avoid unreliable generation) + +# # This does not generate all possible unicode identifiers, as I did not find +# # a way to find all characters that NFKC normalize to a valid character. +# def generate_chr(attempt = 0): +# c = chr( random.randrange( sys.maxunicode + 1 ) ) +# if is_allowed_unicode_char( c, 0 ): +# return c +# return generate_chr( attempt + 1 ) + +# candidate_str = ''.join( [ +# c +# for _ in range( length ) +# if ( c := generate_chr() ) +# ] ) + +# if not iskeyword( candidate_str ): +# return candidate_str +# return generate_unicode_identifier( length = length ) + +# def generate_ascii_identifier( length = 16 ): +# # Only a small subset of valid Python 3 Identifiers, but: +# # - Highly readable +# # - Still millions of combinations +# # - More trivial to generate +# MIN_ASCII = 33 +# MAX_ASCII = 126 + +# def generate_chr( position, attempts = 0 ): +# character = chr( random.randrange( MIN_ASCII, MAX_ASCII ) ) +# if is_allowed_unicode_char( character, position ): +# return character +# return generate_chr( position, attempts + 1) + +# candidate_str = '_' + ''.join( [ +# generate_chr( pos ) +# for pos in range( length - 1 ) +# ] ) + +# if not iskeyword( candidate_str ) and candidate_str.isidentifier(): +# return candidate_str +# return generate_ascii_identifier( length = length ) + + +# # for k in range( 5 ): +# # ident = generate_ascii_identifier() +# # print(ident, len(ident)) + + + +# # PROBLEM: +# # - nested classes are gross +# # - having no nested classes with their actual names results in namespace clashes +# # SOLUTION: +# # a) +# # - queries with no parents get their actual name for their object name +# # - queries with parents get an internal name, and are added to the parent with their real name via `__subclasses__()` and `setattr(...)` +# # b) +# # - infrastructure exists for type hoisting, but it may not be useful in this situation + +# # print(C()) +# # print(C().D()) + +# # print( A() ) +# # for q in A().children: +# # print( q(), q().parent() ) +# # for u in q().children: +# # print( u(), u().parent() ) diff --git a/wcl/query.py b/wcl/query.py index 94c131d..5ef1c3d 100644 --- a/wcl/query.py +++ b/wcl/query.py @@ -1,411 +1,469 @@ -from copy import deepcopy - -class Query: - # params - query_params = {} - cacheable = True - - # internal objects - args = {} - children = None - fields = [] - name = None - parent = None - paginator = { - 'paginationField': None, - 'overrides': None, - 'callback': None - } - - def components( self ): - pagination_field = self.paginator.get( 'paginationField' ) - return { - 'name': self.name, - 'args': { - argk: GQL_Type_Handler( argt, self.query_params.get( argk ) ) - for argk, argt in self.args.items() - if self.query_params.get( argk ) is not None - }, - 'fields': [ - field if isinstance( field, dict ) else { 'name': field } - for field in self.fields + [ self.children, pagination_field ] - if field is not None - ] - } # yapf: disable - - def __init__( self, query_params, cacheable=None ): - self.query_params = deepcopy( query_params ) - - self.children = self.query_params.get( 'children' ) - self.tree = self.create_tree() - self.string = self.stringify() - self.cacheable = cacheable if cacheable is not None else self.cacheable - - def update( self, params ): - assert all( [ - type( self.query_params.get( key ) ) is type( params.get( key ) ) or params.get( key ) is None - for key in self.query_params - ] ), 'Types of values do not match' - assert params != self.query_params, 'Params are unchanged' - - self.query_params.update( params ) - self.tree = self.create_tree() - - def create_tree( self ): - self.query_params.update( { - 'children': self.components() - } ) - - if self.parent is None: - return self.query_params.get( 'children' ) - return self.parent( self.query_params ).tree - - def stringify( self ): - def recurse_nodes( node ): - alias = node.get( 'alias' ) - name = node.get( 'name' ) - args = [] - fields = [] - if node.get( 'args' ): - args = [ str( key ) + ': ' + str( value ) for key, value in node.get( 'args' ).items() ] - if node.get( 'fields' ): - fields = [ recurse_nodes( child ) for child in node.get( 'fields' ) ] - - alias_str = alias + ': ' if alias else '' - args_str = '(' + ', '.join( args ) + ')' if args else '' - fields_str = '{' + ', '.join( fields ) + '}' if fields else '' - - return alias_str + name + args_str + fields_str - - return '{' + recurse_nodes( self.tree ) + '}' - -def GQL_Type_Handler( argt, value ): - if isinstance( argt, list ): - return GQL_List( value, argt[ 0 ] ) - return argt( value ) - -class GQL_Type: - def __init__( self, value ): - self.value = value - -class GQL_Boolean( GQL_Type ): - def __str__( self ): - return str( self.value and 'true' or 'false' ) - -class GQL_String( GQL_Type ): - def __str__( self ): - return '"' + str( self.value ) + '"' - -class GQL_Int( GQL_Type ): - def __str__( self ): - return str( self.value ) - -class GQL_Float( GQL_Type ): - def __str__( self ): - return str( self.value ) - -class GQL_Enum( GQL_Type ): - allowed = [] - - def __str__( self ): - assert self.value in self.allowed, f'{self.value} not in Enum {self.__class__.__name__}' - return self.value - -class GQL_List( GQL_Type ): - def __init__( self, value, secondaryType ): - super().__init__( value ) - self.secondaryType = secondaryType - - def __str__( self ): - assert self.secondaryType is not None, 'Secondary type is not defined for list object' - assert isinstance( self.value, list ), 'Values are not a list' - return '[' + ', '.join( [ str( self.secondaryType( val ) ) for val in self.value ] ) + ']' - -# TODO: Generate this from GraphQL schema - -class GQL_EventDataType( GQL_Enum ): - allowed = [ - 'All', - 'Buffs', - 'Casts', - 'CombatantInfo', - 'DamageDone', - 'DamageTaken', - 'Deaths', - 'Debuffs', - 'Dispels', - 'Healing', - 'Interrupts', - 'Resources', - 'Summons', - 'Threat', - ] - -class ReportData( Query ): - pass - -class Report( Query ): - parent = ReportData - args = { - 'code': GQL_String - } +# from copy import deepcopy + +# class Query: +# # params +# query_params = {} +# cacheable = True + +# # internal objects +# args = {} +# children = None +# fields = [] +# name = None +# parent = None +# paginator = { +# 'paginationField': None, +# 'overrides': None, +# 'callback': None +# } + +# def components( self ): +# pagination_field = self.paginator.get( 'paginationField' ) +# return { +# 'name': self.name, +# 'args': { +# argk: GQL_Type_Handler( argt, self.query_params.get( argk ) ) +# for argk, argt in self.args.items() +# if self.query_params.get( argk ) is not None +# }, +# 'fields': [ +# field if isinstance( field, dict ) else { 'name': field } +# for field in self.fields + [ self.children, pagination_field ] +# if field is not None +# ] +# } # yapf: disable + +# def __init__( self, query_params, cacheable=None ): +# self.query_params = deepcopy( query_params ) + +# self.children = self.query_params.get( 'children' ) +# self.tree = self.create_tree() +# self.string = self.stringify() +# self.cacheable = cacheable if cacheable is not None else self.cacheable + +# def update( self, params ): +# assert all( [ +# type( self.query_params.get( key ) ) is type( params.get( key ) ) or params.get( key ) is None +# for key in self.query_params +# ] ), 'Types of values do not match' +# assert params != self.query_params, 'Params are unchanged' + +# self.query_params.update( params ) +# self.tree = self.create_tree() + +# def create_tree( self ): +# self.query_params.update( { +# 'children': self.components() +# } ) + +# if self.parent is None: +# return self.query_params.get( 'children' ) +# return self.parent( self.query_params ).tree + +# def stringify( self ): +# def recurse_nodes( node ): +# alias = node.get( 'alias' ) +# name = node.get( 'name' ) +# args = [] +# fields = [] +# if node.get( 'args' ): +# args = [ str( key ) + ': ' + str( value ) for key, value in node.get( 'args' ).items() ] +# if node.get( 'fields' ): +# fields = [ recurse_nodes( child ) for child in node.get( 'fields' ) ] + +# alias_str = alias + ': ' if alias else '' +# args_str = '(' + ', '.join( args ) + ')' if args else '' +# fields_str = '{' + ', '.join( fields ) + '}' if fields else '' + +# return alias_str + name + args_str + fields_str + +# return '{' + recurse_nodes( self.tree ) + '}' + +# def GQL_Type_Handler( argt, value ): +# if isinstance( argt, list ): +# return GQL_List( value, argt[ 0 ] ) +# return argt( value ) + +# class GQL_Type: +# def __init__( self, value ): +# self.value = value + +# class GQL_Boolean( GQL_Type ): +# def __str__( self ): +# return str( self.value and 'true' or 'false' ) + +# class GQL_String( GQL_Type ): +# def __str__( self ): +# return '"' + str( self.value ) + '"' + +# class GQL_Int( GQL_Type ): +# def __str__( self ): +# return str( self.value ) + +# class GQL_Float( GQL_Type ): +# def __str__( self ): +# return str( self.value ) + +# class GQL_Enum( GQL_Type ): +# allowed = [] + +# def __str__( self ): +# assert self.value in self.allowed, f'{self.value} not in Enum {self.__class__.__name__}' +# return self.value + +# class GQL_List( GQL_Type ): +# def __init__( self, value, secondaryType ): +# super().__init__( value ) +# self.secondaryType = secondaryType + +# def __str__( self ): +# assert self.secondaryType is not None, 'Secondary type is not defined for list object' +# assert isinstance( self.value, list ), 'Values are not a list' +# return '[' + ', '.join( [ str( self.secondaryType( val ) ) for val in self.value ] ) + ']' + +# # TODO: Generate this from GraphQL schema + +# class GQL_EventDataType( GQL_Enum ): +# allowed = [ +# 'All', +# 'Buffs', +# 'Casts', +# 'CombatantInfo', +# 'DamageDone', +# 'DamageTaken', +# 'Deaths', +# 'Debuffs', +# 'Dispels', +# 'Healing', +# 'Interrupts', +# 'Resources', +# 'Summons', +# 'Threat', +# ] + +# class ReportData( Query ): +# pass + +# class Report( Query ): +# parent = ReportData +# args = { +# 'code': GQL_String +# } + +# class PlayerDetails( Query ): +# parent = Report +# args = { +# 'difficulty': GQL_Int, +# 'encounterID': GQL_Int, +# 'endTime': GQL_Float, +# 'fightIDs': [ GQL_Int ], +# # 'killType': GQL_KillType, +# 'startTime': GQL_Float, +# 'translate': GQL_Boolean +# } + +# class MasterData( Query ): +# parent = Report +# args = { +# 'translate': GQL_Boolean +# } + +# class Actors( Query ): +# parent = MasterData +# args = { +# 'type': GQL_String, +# 'subType': GQL_String +# } + +# fields = [ 'gameID', 'icon', 'id', 'name', 'petOwner', 'server', 'subType', 'type' ] + +# class RateLimitData( Query ): +# pass + +# class PointsSpentThisHour( Query ): +# parent = RateLimitData +# cacheable = False + +# class Fights( Query ): +# parent = Report +# cacheable = False +# fields = [ 'id', 'encounterID', 'name', 'difficulty', 'kill', 'startTime', 'endTime' ] + +# class Events( Query ): +# parent = Report +# paginator = { +# 'paginationField': 'nextPageTimestamp', +# 'overrides': 'startTime' +# } + +# args = { +# 'abilityID': GQL_Float, +# 'dataType': GQL_EventDataType, +# 'death': GQL_Int, +# 'difficulty': GQL_Int, +# 'encounterID': GQL_Int, +# 'endTime': GQL_Float, +# 'fightIDs': [ GQL_Int ], +# 'filterExpression': GQL_String, +# # 'hostilityType': GQL_HostilityType, +# 'includeResources': GQL_Boolean, +# # 'killType': GQL_KillType, +# 'limit': GQL_Int, +# 'sourceAurasAbsent': GQL_String, +# 'sourceAurasPresent': GQL_String, +# 'sourceClass': GQL_String, +# 'sourceID': GQL_Int, +# 'sourceInstanceID': GQL_Int, +# 'startTime': GQL_Float, +# 'targetAurasAbsent': GQL_String, +# 'targetAurasPresent': GQL_String, +# 'targetClass': GQL_String, +# 'targetID': GQL_Int, +# 'targetInstanceID': GQL_Int, +# 'translate': GQL_Boolean, +# 'useAbilityIDs': GQL_Boolean, +# 'useActorIDs': GQL_Boolean, +# 'viewOptions': GQL_Int, +# 'wipeCutoff': GQL_Int +# } + +# fields = [ 'data' ] + +# class Reports( Query ): +# parent = ReportData +# paginator = { +# 'paginationField': 'current_page', +# 'overrides': 'page' +# } + +# args = { +# 'endTime': GQL_Float, +# 'guildID': GQL_Int, +# 'guildName': GQL_String, +# 'guildServerSlug': GQL_String, +# 'guildServerRegion': GQL_String, +# 'guildTagID': GQL_Int, +# 'userID': GQL_Int, +# 'limit': GQL_Int, +# 'page': GQL_Int, +# 'startTime': GQL_Float, +# 'zoneID': GQL_Int, +# 'gameZoneID': GQL_Int +# } + +# fields = [ +# 'data', +# 'total', +# 'per_page', +# 'current_page', +# 'from', +# 'to', +# 'last_page', +# 'has_more_pages' +# ] + +# # GQL 2.0 +# # object_name( {argument_key: argument_value, ...} ){ [field, ...] } + +# class GQL_OBJECT: +# # Provided by instantiator +# alias = None +# args = {} +# fields = {} + +# # Provided by code generation +# arg_types = {} +# field_types = {} +# name = None +# parent = None +# paginator = { +# 'field': None, +# 'replaces': None, +# 'callback': None +# } -class PlayerDetails( Query ): - parent = Report - args = { - 'difficulty': GQL_Int, - 'encounterID': GQL_Int, - 'endTime': GQL_Float, - 'fightIDs': [ GQL_Int ], - # 'killType': GQL_KillType, - 'startTime': GQL_Float, - 'translate': GQL_Boolean - } - -class MasterData( Query ): - parent = Report - args = { - 'translate': GQL_Boolean - } - -class Actors( Query ): - parent = MasterData - args = { - 'type': GQL_String, - 'subType': GQL_String - } - - fields = [ 'gameID', 'icon', 'id', 'name', 'petOwner', 'server', 'subType', 'type' ] - -class RateLimitData( Query ): - pass - -class PointsSpentThisHour( Query ): - parent = RateLimitData - cacheable = False - -class Fights( Query ): - parent = Report - cacheable = False - fields = [ 'id', 'encounterID', 'name', 'difficulty', 'kill', 'startTime', 'endTime' ] - -class Events( Query ): - parent = Report - paginator = { - 'paginationField': 'nextPageTimestamp', - 'overrides': 'startTime' - } - - args = { - 'abilityID': GQL_Float, - 'dataType': GQL_EventDataType, - 'death': GQL_Int, - 'difficulty': GQL_Int, - 'encounterID': GQL_Int, - 'endTime': GQL_Float, - 'fightIDs': [ GQL_Int ], - 'filterExpression': GQL_String, - # 'hostilityType': GQL_HostilityType, - 'includeResources': GQL_Boolean, - # 'killType': GQL_KillType, - 'limit': GQL_Int, - 'sourceAurasAbsent': GQL_String, - 'sourceAurasPresent': GQL_String, - 'sourceClass': GQL_String, - 'sourceID': GQL_Int, - 'sourceInstanceID': GQL_Int, - 'startTime': GQL_Float, - 'targetAurasAbsent': GQL_String, - 'targetAurasPresent': GQL_String, - 'targetClass': GQL_String, - 'targetID': GQL_Int, - 'targetInstanceID': GQL_Int, - 'translate': GQL_Boolean, - 'useAbilityIDs': GQL_Boolean, - 'useActorIDs': GQL_Boolean, - 'viewOptions': GQL_Int, - 'wipeCutoff': GQL_Int - } - - fields = [ 'data' ] - -class Reports( Query ): - parent = ReportData - paginator = { - 'paginationField': 'current_page', - 'overrides': 'page' - } - - args = { - 'endTime': GQL_Float, - 'guildID': GQL_Int, - 'guildName': GQL_String, - 'guildServerSlug': GQL_String, - 'guildServerRegion': GQL_String, - 'guildTagID': GQL_Int, - 'userID': GQL_Int, - 'limit': GQL_Int, - 'page': GQL_Int, - 'startTime': GQL_Float, - 'zoneID': GQL_Int, - 'gameZoneID': GQL_Int - } - - fields = [ - 'data', - 'total', - 'per_page', - 'current_page', - 'from', - 'to', - 'last_page', - 'has_more_pages' - ] - -# GQL 2.0 -# object_name( {argument_key: argument_value, ...} ){ [field, ...] } - -class GQL_OBJECT: - # Provided by instantiator - alias = None - args = {} - fields = {} - - # Provided by code generation - arg_types = {} - field_types = {} - name = None - parent = None - paginator = { - 'field': None, - 'replaces': None, - 'callback': None - } - - def __init__( self, args, fields ): - # Update name of child in fields and in the child object - # children may have multiple parents, and be called different things by each - if fields.get( 'child' ) is not None: - expected_name = None - child = fields[ 'child' ] - for name, t in self.field_types.items(): - if isinstance( child, t ): - expected_name = name - break - if expected_name is not None: - fields.update( { expected_name: child } ) - fields[ expected_name ].name = expected_name - fields.pop( 'child' ) - - - # Verify all arguments and fields are of the expected types - assert all( [ - isinstance( arg_v, expected_type ) - for arg_k, arg_v in args.items() - if ( expected_type := self.arg_types.get( arg_k ) ) - ] ), f'Not all args are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{args}\n{self.arg_types}' - assert all( [ - isinstance( field_v, expected_type ) - for field_k, field_v in fields.items() - if ( expected_type := self.field_types.get( field_k ) ) - ] ), f'Not all fields are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{fields}\n{self.field_types}' - - self.args = args - self.fields = fields - - def __str__( self ): - args = [ - f'{key}: {str( value )}' - for key, value in self.args.items() - if hasattr( value, '__str__' ) and key in self.arg_types.keys() - ] # yapf: disable - fields = [ - f'{str( value )}' - for key, value in self.fields.items() - if hasattr( value, '__str__' ) and key in self.field_types.keys() - ] # yapf: disable - args_str = ('(' if len( args ) > 0 else '') + ','.join( args ) + (')' if len( args ) > 0 else '') - fields_str = ('{' if len( fields ) > 0 else '') + ','.join( fields ) + ('}' if len( fields ) > 0 else '') - alias_str = self.alias + ': ' if self.alias is not None else '' - return f'{alias_str}{self.name}{args_str}{fields_str}' - - def tree( self ): - if self.parent is not None: - # print( f'creating {self.parent.__name__} with:\nargs: {self.args}\nfields: {self.fields | { "child": self }}') - return self.parent( self.args, self.fields | { 'child': self } ).tree() - return self +# def __init__( self, args, fields ): +# # Update name of child in fields and in the child object +# # children may have multiple parents, and be called different things by each +# if fields.get( 'child' ) is not None: +# expected_name = None +# child = fields[ 'child' ] +# for name, t in self.field_types.items(): +# if isinstance( child, t ): +# expected_name = name +# break +# if expected_name is not None: +# fields.update( { +# expected_name: child +# } ) +# fields[ expected_name ].name = expected_name +# fields.pop( 'child' ) + +# # Verify all arguments and fields are of the expected types +# assert all( [ +# isinstance( arg_v, expected_type ) +# for arg_k, arg_v in args.items() +# if ( expected_type := self.arg_types.get( arg_k ) ) +# ] ), f'Not all args are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{args}\n{self.arg_types}' +# assert all( [ +# isinstance( field_v, expected_type ) +# for field_k, field_v in fields.items() +# if ( expected_type := self.field_types.get( field_k ) ) +# ] ), f'Not all fields are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{fields}\n{self.field_types}' + +# self.args = args +# self.fields = fields + +# def __str__( self ): +# args = [ +# f'{key}: {str( value )}' +# for key, value in self.args.items() +# if hasattr( value, '__str__' ) and key in self.arg_types.keys() +# ] # yapf: disable +# fields = [ +# f'{str( value )}' +# for key, value in self.fields.items() +# if hasattr( value, '__str__' ) and key in self.field_types.keys() +# ] # yapf: disable +# args_str = ( '(' if len( args ) > 0 else +# '' ) + ','.join( args ) + ( ')' if len( args ) > 0 else '' ) +# fields_str = ( '{' if len( fields ) > 0 else +# '' ) + ','.join( fields ) + ( '}' if len( fields ) > 0 else '' ) +# alias_str = self.alias + ': ' if self.alias is not None else '' +# return f'{alias_str}{self.name}{args_str}{fields_str}' + +# def tree( self ): +# if self.parent is not None: +# # print( f'creating {self.parent.__name__} with:\nargs: {self.args}\nfields: {self.fields | { "child": self }}') +# return self.parent( self.args, +# self.fields | { +# 'child': self +# } ).tree() +# return self + +# class GQL_SCALAR: +# def __init__( self, value ): +# self.value = value + +# def __str__( self ): +# return f'{self.value}' + +# class GQL_SCALAR_Boolean( GQL_SCALAR ): +# def __str__( self ): +# return f'{self.value and "true" or "false"}' + +# class GQL_SCALAR_Float( GQL_SCALAR ): +# pass + +# class GQL_SCALAR_Int( GQL_SCALAR ): +# pass + +# class GQL_SCALAR_String( GQL_SCALAR ): +# def __str__( self ): +# return f'"{self.value}"' + +# class GQL_ENUM: +# allowed = [] + +# def __init__( self, value ): +# self.value = value + +# def __str__( self ): +# assert self.value in self.allowed, f'{self.value} is not in Enum {self.__class__.__name__}.' +# return f'{self.value}' + +# # class GQL_OBJECT_( GQL_Object ): +# # def __init__( self, args, fields ): +# # self.arg_types = { +# # : GQL_, +# # ... +# # } +# # self.field_types = { +# # : GQL_, +# # ... +# # } +# # self.name = +# # self.parent = GQL_ +# # self.paginator = { +# # 'field': , +# # 'replaces': , +# # 'callback': +# # } +# # super().__init__( args, fields ) +# class GQL_Test1( GQL_OBJECT ): +# def __init__( self, args, fields ): +# self.name = 'test-one' +# self.field_types = { +# 'newname-two': GQL_Test2 +# } +# super().__init__( args, fields ) -class GQL_SCALAR: - def __init__( self, value ): - self.value = value +# class GQL_Test2( GQL_OBJECT ): +# def __init__( self, args, fields ): +# self.name = 'test-two' +# self.parent = GQL_Test1 +# super().__init__( args, fields ) - def __str__( self ): - return f'{self.value}' +""" +1. each object uses the canonical GQL typename as its name +2. each object contains two sets of references: args and fields +2. each reference contains GQL typename, local aliased name and metadata +""" +""" +BASE KINDS: +SCALAR, +OBJECT, +ENUM + +META KINDS: +NON_NULL, +LIST +""" +""" +META TYPE KINDS +""" + +class GQL_KIND: + def __init__( self, data ): + self.data = data + assert self.is_valid() -class GQL_SCALAR_Boolean( GQL_SCALAR ): def __str__( self ): - return f'{self.value and "true" or "false"}' + return str( self.data ) -class GQL_SCALAR_Float( GQL_SCALAR ): - pass + def is_valid( self ): + return False -class GQL_SCALAR_Int( GQL_SCALAR ): - pass +class GQL_SCALAR( GQL_KIND ): + def is_valid( self ): + return True -class GQL_SCALAR_String( GQL_SCALAR ): - def __str__( self ): - return f'"{self.value}"' +class GQL_ENUM( GQL_KIND ): + enum_values = [] -class GQL_ENUM: - allowed = [] + def is_valid( self ): + return self.data in self.enum_values - def __init__( self, value ): - self.value = value +class GQL_NON_NULL( GQL_KIND ): + def is_valid( self ): + return isinstance( self.data, GQL_KIND ) and self.data.is_valid() +class GQL_LIST( GQL_KIND ): def __str__( self ): - assert self.value in self.allowed, f'{self.value} is not in Enum {self.__class__.__name__}.' - return f'{self.value}' + return '[' + ', '.join( [ str( datum ) for datum in self.data ] ) + ']' -# class GQL_OBJECT_( GQL_Object ): -# def __init__( self, args, fields ): -# self.arg_types = { -# : GQL_, -# ... -# } -# self.field_types = { -# : GQL_, -# ... -# } -# self.name = -# self.parent = GQL_ -# self.paginator = { -# 'field': , -# 'replaces': , -# 'callback': -# } -# super().__init__( args, fields ) -class GQL_Test1( GQL_OBJECT ): - def __init__( self, args, fields ): - self.name = 'test-one' - self.field_types = { - 'newname-two': GQL_Test2 - } - super().__init__( args, fields ) - -class GQL_Test2( GQL_OBJECT ): - def __init__( self, args, fields ): - self.name = 'test-two' - self.parent = GQL_Test1 - super().__init__( args, fields ) + def is_valid( self ): + return isinstance( self.data, list ) and all( [ hasattr( datum, 'is_valid' ) and datum.is_valid() for datum in self.data ] ) # yapf: disable if __name__ == '__main__': import json - import request - from itertools import product + from request import Request class SchemaIntrospection: schema_location = 'wcl/introspection_query.json' - tree = { 'name': '__schema' } + tree = { + 'name': '__schema' + } paginator = {} cacheable = True @@ -415,123 +473,64 @@ def __str__( self ): return data schema_query = SchemaIntrospection() - schema_request_data = request.Request( schema_query ).data - t = set() - - enums = [] - objects = [] - for entry in schema_request_data[ 'types' ]: - # filter = [ - # 'name', - # 'kind', - # ] - # print([ f'{e}: {v}' for e, v in entry.items() if e in filter ]) - if entry.get( 'kind' ) == 'OBJECT': - objects.append( entry ) - if entry.get( 'kind' ) == 'ENUM': - enums.append( entry ) - - names = [ - e.get('name') - for e in objects - ] - # print( names ) - # print( len(names)) - # print(len(set(names))) - print(json.dumps(objects, indent=2)) - - - # print( 'from .query import GQL_ENUM, GQL_OBJECT') - # for enum in enums: - # name = enum.get( 'name' ) - # descr = enum.get( 'description' ) - # print() - # if descr is not None: - # print( f'# {descr}') - # print( f'class GQL_ENUM_{name}( GQL_ENUM ):') - # print( ' allowed = [') - # max_len = max( [ - # len( enum_value.get( 'name', '' ) ) - # for enum_value in enum.get( 'enumValues' ) - # ] ) + 2 - # enum_values = [ - # { - # 'name': val.get( 'name' ), - # 'desc': val.get( 'description' ), - # } - # for val in enum.get( 'enumValues' ) - # ] - # for enum_value in enum_values: - # enum_value_name = enum_value.get( 'name', '' ) + '\',' - # enum_value_descr = enum_value.get( 'desc', '' ) - # print( f' \'{enum_value_name: <{max_len}} # {enum_value_descr}') - # print( ' ]') - - - # def find_type( obj ): - # base = obj.get( 'type' ) or obj.get( 'ofType' ) - # if base[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - # return base[ 'name' ] - # return find_type( base ) - - # def objects_with_matching_type( type_name ): - # rets = [] - # for obj in objects: - # fields = obj.get( 'fields', [] ) - # for field in fields: - # if type_name == find_type( field ) and field.get( 'args' ) != []: - # rets.append( field ) - # return rets - - # def object_name_from_type( type_obj ): - # if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - # return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' - # if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: - # type_obj = type_obj[ 'ofType' ] - # return f'GQL_{type_obj[ "kind" ]}_{type_obj[ "name" ]}' - - # def object_name( type_obj ): - # if type_obj[ 'kind' ] in [ 'SCALAR', 'ENUM', 'OBJECT' ]: - # return f'{type_obj[ "name" ]}' - # if type_obj[ 'kind' ] in [ 'LIST', 'NON_NULL' ]: - # type_obj = type_obj[ 'ofType' ] - # return f'{type_obj[ "name" ]}' - - # def process_arg_or_field( entry ): - # return { - # 'TYPE': object_name_from_type( entry[ 'type' ] ), - # 'IS_LIST': entry[ 'type' ][ 'kind' ] == 'LIST', - # 'DESCRIPTION': entry[ 'description' ] - # } - - # def objects_have_matching_type( a, b ): - # matches = [ - # object_name( field[ 'type' ] ) == a[ 'name' ] - # for field in b[ 'fields' ] - # ] - # return b[ 'fields' ][ matches.index( True ) ] if True in matches else False - - # objects = [ - # { - # 'TYPE_NAME': base[ 'name' ], - # 'NAME': variant_obj[ 'name' ], - # 'VARIANT_COUNT': max( 1, len( objects_with_matching_type( base[ 'name' ] ) ) ), - # 'PARENT': None, - # 'ARGS': { - # arg[ 'name' ]: process_arg_or_field( arg ) - # for arg in variant_obj[ 'args' ] - # }, - # 'FIELDS': { - # field[ 'name' ]: process_arg_or_field( field ) - # for field in base[ 'fields' ] - # }, - # 'DESCRIPTION': [ - # description - # for description in [ base[ 'description' ], variant_obj[ 'description' ] ] - # if description - # ] - # } - # for base, variant in product( objects, objects ) - # if base[ 'name' ][ :2 ] != '__' - # if ( variant_obj := objects_have_matching_type( base, variant ) ) - # ] + schema_request_data = Request( schema_query ).data + + tab = ' ' + objects = { + 'ENUM': [ +"""from query import GQL_ENUM + +\"\"\" +ENUM TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +\"\"\"""" + ], + 'OBJECT': [ +"""from query import GQL_Object +import enum +import scalar + +\"\"\" +OBJECT TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +\"\"\"""" + ] + } + + def handle_enum( entry ): + assert entry[ 'kind' ] == 'ENUM' + longest_str = max( [ len( enum_value[ 'name' ] ) for enum_value in entry[ 'enumValues' ] ] ) + lines = [ + f'class GQL_{entry["name"]}( GQL_ENUM ):', + f'{tab}enum_values = [', + *[ + f'{tab*2}\'{name}\',{" "*(longest_str-len(name))} # {desc}' + for enum_value in entry['enumValues'] + if ( name := enum_value['name'] ) + if ( desc := enum_value['description'] ) + ], + f'{tab}]' + ] # yapf: disable + return '\n'.join( lines ) + + def handle_object( entry ): + return "" + + for k in schema_request_data[ 'types' ]: + kind = k[ 'kind' ] + if kind in objects.keys(): + current = objects[ kind ] + match kind: + case 'ENUM': + current.append( handle_enum( k ) ) + case 'OBJECT': + current.append( handle_object( k ) ) + case _: + pass + + objects.update( { + kind: current + } ) + for kind, values in objects.items(): + with open( f'wcl/types/{kind.lower()}.py', 'w' ) as handle: + handle.write( '\n\n'.join( values ) ) diff --git a/wcl/query_generated.py b/wcl/query_generated.py deleted file mode 100644 index fa702da..0000000 --- a/wcl/query_generated.py +++ /dev/null @@ -1,89 +0,0 @@ -from .query import GQL_ENUM, GQL_OBJECT - -class GQL_ENUM_CharacterRankingMetricType( GQL_ENUM ): - allowed = [ - 'bosscdps', - 'bossdps', - 'bossndps', - 'bossrdps', - 'default', - 'dps', - 'hps', - 'krsi', - 'playerscore', - 'playerspeed', - 'cdps', - 'ndps', - 'rdps', - 'tankhps', - 'wdps', - 'healercombineddps', - 'healercombinedbossdps', - 'healercombinedcdps', - 'healercombinedbosscdps', - 'healercombinedndps', - 'healercombinedbossndps', - 'healercombinedrdps', - 'healercombinedbossrdps', - 'tankcombineddps', - 'tankcombinedbossdps', - 'tankcombinedcdps', - 'tankcombinedbosscdps', - 'tankcombinedndps', - 'tankcombinedbossndps', - 'tankcombinedrdps', - 'tankcombinedbossrdps ', - ] - -class GQL_ENUM_EventDataType( GQL_ENUM ): - allowed = [ - 'All', - 'Buffs', - 'Casts', - 'CombatantInfo', - 'DamageDone', - 'DamageTaken', - 'Deaths', - 'Debuffs', - 'Dispels', - 'Healing', - 'Interrupts', - 'Resources', - 'Summons', - 'Threat ', - ] - -class GQL_ENUM_ExternalBuffRankFilter( GQL_ENUM ): - allowed = [ - 'Any', - 'Require', - 'Exclude' - ] - -class GQL_ENUM_FightRankingMetricType( GQL_ENUM ): - allowed = [ - 'default', - 'execution', - 'feats', - 'score', - 'speed', - 'progress', - ] - -class GQL_ENUM_GraphDataType( GQL_ENUM ): - allowed = [ - 'Summary', - 'Buffs', - 'Casts', - 'DamageDone', - 'DamageTaken', - 'Deaths', - 'Debuffs', - 'Dispels', - 'Healing', - 'Interrupts', - 'Resources', - 'Summons', - 'Survivability', - 'Threat ', - ] diff --git a/wcl/types/enum.py b/wcl/types/enum.py new file mode 100644 index 0000000..f778b6e --- /dev/null +++ b/wcl/types/enum.py @@ -0,0 +1,238 @@ +from query import GQL_ENUM + +""" +ENUM TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +""" + +class GQL_RankingCompareType( GQL_ENUM ): + enum_values = [ + 'Rankings', # Compare against rankings. + 'Parses', # Compare against all parses in a two week window. + ] + +class GQL_CharacterRankingMetricType( GQL_ENUM ): + enum_values = [ + 'bosscdps', # Boss cDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs. + 'bossdps', # Boss damage per second. + 'bossndps', # Boss nDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs. + 'bossrdps', # Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs. + 'default', # Choose an appropriate default depending on the other selected parameters. + 'dps', # Damage per second. + 'hps', # Healing per second. + 'krsi', # Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones. + 'playerscore', # Score. Used by WoW Mythic dungeons and by ESO trials. + 'playerspeed', # Speed. Not supported by every zone. + 'cdps', # cDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs. + 'ndps', # nDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs. + 'rdps', # rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs. + 'tankhps', # Healing done per second to tanks. + 'wdps', # Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets. + 'healercombineddps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedbossdps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedcdps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedbosscdps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedndps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedbossndps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedrdps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'healercombinedbossrdps', # Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content. + 'tankcombineddps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedbossdps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedcdps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedbosscdps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedndps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedbossndps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedrdps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + 'tankcombinedbossrdps', # Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content. + ] + +class GQL_RoleType( GQL_ENUM ): + enum_values = [ + 'Any', # Fetch any role.. + 'DPS', # Fetch the DPS role only. + 'Healer', # Fetch the healer role only. + 'Tank', # Fetch the tanking role only. + ] + +class GQL_RankingTimeframeType( GQL_ENUM ): + enum_values = [ + 'Today', # Compare against today's rankings. + 'Historical', # Compare against historical rankings. + ] + +class GQL_LeaderboardRank( GQL_ENUM ): + enum_values = [ + 'Any', # All ranks are included. + 'LogsOnly', # Only include ranks with a backing log. + ] + +class GQL_HardModeLevelRankFilter( GQL_ENUM ): + enum_values = [ + 'Any', # Any hard mode level (including normal mode). + 'Highest', # The highest hard mode level. Convenience alias for hard mode level 4. + 'NormalMode', # The normal (non-hard) mode level. Convenience alias for hard mode level 0. + 'Level0', # Hard mode level 0. + 'Level1', # Hard mode level 1. + 'Level2', # Hard mode level 2. + 'Level3', # Hard mode level 3. + 'Level4', # Hard mode level 4. + ] + +class GQL_ExternalBuffRankFilter( GQL_ENUM ): + enum_values = [ + 'Any', # Include all ranks, regardless of external buffs. + 'Require', # Only include ranks that DO CONTAIN external buffs. + 'Exclude', # Only include ranks that DO NOT CONTAIN external buffs. + ] + +class GQL_FightRankingMetricType( GQL_ENUM ): + enum_values = [ + 'default', # Choose an appropriate default depending on the other selected parameters. + 'execution', # A metric that rewards minimizing deaths and damage taken. + 'feats', # Feats of strength in WoW or Challenges in FF. + 'score', # For Mythic+ dungeons in WoW, represents the team's score. Used for ESO trials and dungeons also. + 'speed', # Speed metric, based off the duration of the fight. + 'progress', # Progress metric, based off when the fight was defeated. + ] + +class GQL_GuildRank( GQL_ENUM ): + enum_values = [ + 'NonMember', # The user is not a member of this guild or team. + ] + +class GQL_EventDataType( GQL_ENUM ): + enum_values = [ + 'All', # All Events + 'Buffs', # Buffs. + 'Casts', # Casts. + 'CombatantInfo', # Combatant info events (includes gear). + 'DamageDone', # Damage done. + 'DamageTaken', # Damage taken. + 'Deaths', # Deaths. + 'Debuffs', # Debuffs. + 'Dispels', # Dispels. + 'Healing', # Healing done. + 'Interrupts', # Interrupts. + 'Resources', # Resources. + 'Summons', # Summons + 'Threat', # Threat. + ] + +class GQL_HostilityType( GQL_ENUM ): + enum_values = [ + 'Friendlies', # Fetch information for friendlies. + 'Enemies', # Fetch information for enemies. + ] + +class GQL_KillType( GQL_ENUM ): + enum_values = [ + 'All', # Include trash and encounters. + 'Encounters', # Only include encounters (kills and wipes). + 'Kills', # Only include encounters that end in a kill. + 'Trash', # Only include trash. + 'Wipes', # Only include encounters that end in a wipe. + ] + +class GQL_GraphDataType( GQL_ENUM ): + enum_values = [ + 'Summary', # Summary Overview + 'Buffs', # Buffs. + 'Casts', # Casts. + 'DamageDone', # Damage done. + 'DamageTaken', # Damage taken. + 'Deaths', # Deaths. + 'Debuffs', # Debuffs. + 'Dispels', # Dispels. + 'Healing', # Healing done. + 'Interrupts', # Interrupts. + 'Resources', # Resources. + 'Summons', # Summons + 'Survivability', # Survivability (death info across multiple pulls). + 'Threat', # Threat. + ] + +class GQL_ViewType( GQL_ENUM ): + enum_values = [ + 'Default', # Use the same default that the web site picks based off the other selected parameters. + 'Ability', # View by ability. + 'Source', # View. by source. + 'Target', # View by target. + ] + +class GQL_ReportRankingMetricType( GQL_ENUM ): + enum_values = [ + 'bossdps', # Boss damage per second. + 'bossrdps', # Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs. + 'default', # Choose an appropriate default depending on the other selected parameters. + 'dps', # Damage per second. + 'hps', # Healing per second. + 'krsi', # Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones. + 'playerscore', # Score. Used by WoW Mythic dungeons and by ESO trials. + 'playerspeed', # Speed. Not supported by every zone. + 'rdps', # rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs. + 'tankhps', # Healing done per second to tanks. + 'wdps', # Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets. + ] + +class GQL_TableDataType( GQL_ENUM ): + enum_values = [ + 'Summary', # Summary Overview + 'Buffs', # Buffs. + 'Casts', # Casts. + 'DamageDone', # Damage done. + 'DamageTaken', # Damage taken. + 'Deaths', # Deaths. + 'Debuffs', # Debuffs. + 'Dispels', # Dispels. + 'Healing', # Healing done. + 'Interrupts', # Interrupts. + 'Resources', # Resources. + 'Summons', # Summons + 'Survivability', # Survivability (death info across multiple pulls). + 'Threat', # Threat. + ] + +class GQL___TypeKind( GQL_ENUM ): + enum_values = [ + 'SCALAR', # Indicates this type is a scalar. + 'OBJECT', # Indicates this type is an object. `fields` and `interfaces` are valid fields. + 'INTERFACE', # Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields. + 'UNION', # Indicates this type is a union. `possibleTypes` is a valid field. + 'ENUM', # Indicates this type is an enum. `enumValues` is a valid field. + 'INPUT_OBJECT', # Indicates this type is an input object. `inputFields` is a valid field. + 'LIST', # Indicates this type is a list. `ofType` is a valid field. + 'NON_NULL', # Indicates this type is a non-null. `ofType` is a valid field. + ] + +class GQL___DirectiveLocation( GQL_ENUM ): + enum_values = [ + 'QUERY', # Location adjacent to a query operation. + 'MUTATION', # Location adjacent to a mutation operation. + 'SUBSCRIPTION', # Location adjacent to a subscription operation. + 'FIELD', # Location adjacent to a field. + 'FRAGMENT_DEFINITION', # Location adjacent to a fragment definition. + 'FRAGMENT_SPREAD', # Location adjacent to a fragment spread. + 'INLINE_FRAGMENT', # Location adjacent to an inline fragment. + 'VARIABLE_DEFINITION', # Location adjacent to a variable definition. + 'SCHEMA', # Location adjacent to a schema definition. + 'SCALAR', # Location adjacent to a scalar definition. + 'OBJECT', # Location adjacent to an object type definition. + 'FIELD_DEFINITION', # Location adjacent to a field definition. + 'ARGUMENT_DEFINITION', # Location adjacent to an argument definition. + 'INTERFACE', # Location adjacent to an interface definition. + 'UNION', # Location adjacent to a union definition. + 'ENUM', # Location adjacent to an enum definition. + 'ENUM_VALUE', # Location adjacent to an enum value definition. + 'INPUT_OBJECT', # Location adjacent to an input object type definition. + 'INPUT_FIELD_DEFINITION', # Location adjacent to an input object field definition. + ] + +class GQL_SubscriptionStatus( GQL_ENUM ): + enum_values = [ + 'Silver', # Silver Tier subscription + 'Gold', # Gold Tier subscription + 'Platinum', # Platinum Tier subscription + 'LegacySilver', # Legacy Silver Tier subscription + 'LegacyGold', # Legacy Gold Tier subscription + 'LegacyPlatinum', # Legacy Platinum Tier subscription + ] \ No newline at end of file diff --git a/wcl/types/object.py b/wcl/types/object.py new file mode 100644 index 0000000..0f4acb7 --- /dev/null +++ b/wcl/types/object.py @@ -0,0 +1,155 @@ +from query import GQL_Object +import enum +import scalar + +""" +OBJECT TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +""" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/wcl/types/scalar.py b/wcl/types/scalar.py new file mode 100644 index 0000000..2de2b3a --- /dev/null +++ b/wcl/types/scalar.py @@ -0,0 +1,32 @@ +from query import GQL_SCALAR + +""" +SCALAR TYPES + +THIS FILE IS NOT GENERATED +""" + +class GQL_Int( GQL_SCALAR ): + def is_valid( self ): + return isinstance( self.data, int ) + +class GQL_String( GQL_SCALAR ): + def __str__( self ): + return f'"{self.data}"' + +class GQL_Boolean( GQL_SCALAR ): + def is_valid( self ): + return isinstance( self.data, bool ) + + def __str__( self ): + return 'true' if self.data else 'false' + +class GQL_JSON( GQL_SCALAR ): + pass + +class GQL_Float( GQL_SCALAR ): + def is_valid( self ): + return isinstance( self.data, float ) + +class GQL_ID( GQL_SCALAR ): + pass From 530e864be4006035a722eb4e346cb5de38a4f016 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Mon, 26 Feb 2024 03:20:30 -0700 Subject: [PATCH 6/7] a little reorganization and it's kindaish getting close. ill move the generated types out of git eventually... --- wcl/__init__.py | 6 +- wcl/__main__.py | 183 ++ wcl/query.py | 508 +---- wcl/types/__init__.py | 8 + wcl/types/enum.py | 2 +- wcl/types/object.py | 4370 +++++++++++++++++++++++++++++++++++++++-- wcl/types/scalar.py | 2 +- 7 files changed, 4421 insertions(+), 658 deletions(-) create mode 100644 wcl/__main__.py create mode 100644 wcl/types/__init__.py diff --git a/wcl/__init__.py b/wcl/__init__.py index c0d5ec1..75e74d0 100644 --- a/wcl/__init__.py +++ b/wcl/__init__.py @@ -1,2 +1,4 @@ -from .interface import * -from .query import * +# from .interface import * +# from .query import * + +from . import interface, query, request diff --git a/wcl/__main__.py b/wcl/__main__.py new file mode 100644 index 0000000..b1e1b77 --- /dev/null +++ b/wcl/__main__.py @@ -0,0 +1,183 @@ +import json +from .request import Request +from .types import * + +""" +1. each object uses the canonical GQL typename as its name +2. each object contains two sets of references: args and fields +2. each reference contains GQL typename, local aliased name and metadata +""" +""" +BASE KINDS: +SCALAR, +OBJECT, +ENUM + +META KINDS: +NON_NULL, +LIST +""" + +""" +TODO: +sort the objects +make sure i can use the type objects to make the thing :tm: +create a thing that finds the correct query objects +stringify +""" + + +class SchemaIntrospection: + schema_location = 'wcl/introspection_query.json' + tree = { + 'name': '__schema' + } + paginator = {} + cacheable = True + + def __str__( self ): + with open( self.schema_location, 'r' ) as handle: + data = handle.read() + return data + +schema_query = SchemaIntrospection() +schema_request_data = Request( schema_query ).data + +objects = { + 'ENUM': [ +"""from ..query import GQL_ENUM + +\"\"\" +ENUM TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +\"\"\"""" + ], + 'OBJECT': [ +"""from ..query import * +from .enum import * +from .scalar import * + +\"\"\" +OBJECT TYPES +THIS FILE IS GENERATED BY `wcl/query.py`. +\"\"\"""" + ] +} + +tab = ' ' +def handle_enum( entry ): + assert entry[ 'kind' ] == 'ENUM' + longest_str = max( [ len( enum_value[ 'name' ] ) for enum_value in entry[ 'enumValues' ] ] ) + lines = [ + f'class GQL_{entry["name"]}( GQL_ENUM ):', + f'{tab}enum_values = [', + *[ + f'{tab}{tab}\'{name}\',{" "*(longest_str-len(name))} # {desc}' + for enum_value in entry['enumValues'] + if ( name := enum_value['name'] ) + if ( desc := enum_value['description'] ) + ], + f'{tab}]' + ] # yapf: disable + return '\n'.join( lines ) + +def handle_object( entry ): + def format_type( t ): + type_arr = resolve_type( t ) + return '('.join( type_arr ) + ')' * ( len( type_arr ) - 1 ) + "," + + def resolve_type( t ): + kind = t[ 'kind' ] + if kind in [ 'OBJECT', 'SCALAR', 'ENUM' ]: + name = t[ 'name' ] + if kind != 'OBJECT': + return [ f'GQL_{name}' ] + else: + return [ f'"GQL_{name}"' ] + else: + return [ f'GQL_{kind}' ] + resolve_type( t[ 'ofType' ] ) + + def format_field( field ): + def base_filter( field ): + key_filter = [ + 'name', + 'description' + ] + return [ + f'{tab}"{key}": "{value}",' + for key, value in field.items() + if key in key_filter + ] + + def format_arg( arg ): + return [ + '{', + *[ + f'{line}' + for line in base_filter( arg ) + ], + f'{tab}"type": {format_type(arg["type"])}', + '},' + ] + + def format_args( args ): + if args: + return [ + '"args": [', + *[ + f'{tab}{line}' + for arg in args + if ( arg_lines := format_arg( arg ) ) + for line in arg_lines + ], + ']' + ] + return [] + + return [ + '{', + *base_filter( field ), + f'{tab}"type": {format_type(field["type"])}', + *[ + f'{tab}{line}' + for line in format_args( field[ 'args' ] ) + ], + '},' + ] + + assert entry[ 'kind' ] == 'OBJECT' + lines = [ + f'class GQL_{entry["name"]}( GQL_OBJECT ):', + f'{tab}fields = [', + *[ + f'{tab}{tab}{line}' + for field in entry[ 'fields' ] + if ( formatted_field := format_field( field ) ) + for line in formatted_field + ], + f'{tab}]' + ] + print(json.dumps(entry, indent=2)) + print(json.dumps(lines, indent=2)) + return '\n'.join( lines ) + +for k in schema_request_data[ 'types' ]: + kind = k[ 'kind' ] + if kind in objects.keys(): + current = objects[ kind ] + match kind: + case 'ENUM': + current.append( handle_enum( k ) ) + case 'OBJECT': + current.append( handle_object( k ) ) + case _: + pass + + objects.update( { + kind: current + } ) +for kind, values in objects.items(): + with open( f'wcl/types/{kind.lower()}.py', 'w' ) as handle: + handle.write( '\n\n'.join( values ) ) + +scalar.GQL_Boolean( True ) diff --git a/wcl/query.py b/wcl/query.py index 5ef1c3d..b05af00 100644 --- a/wcl/query.py +++ b/wcl/query.py @@ -1,428 +1,3 @@ -# from copy import deepcopy - -# class Query: -# # params -# query_params = {} -# cacheable = True - -# # internal objects -# args = {} -# children = None -# fields = [] -# name = None -# parent = None -# paginator = { -# 'paginationField': None, -# 'overrides': None, -# 'callback': None -# } - -# def components( self ): -# pagination_field = self.paginator.get( 'paginationField' ) -# return { -# 'name': self.name, -# 'args': { -# argk: GQL_Type_Handler( argt, self.query_params.get( argk ) ) -# for argk, argt in self.args.items() -# if self.query_params.get( argk ) is not None -# }, -# 'fields': [ -# field if isinstance( field, dict ) else { 'name': field } -# for field in self.fields + [ self.children, pagination_field ] -# if field is not None -# ] -# } # yapf: disable - -# def __init__( self, query_params, cacheable=None ): -# self.query_params = deepcopy( query_params ) - -# self.children = self.query_params.get( 'children' ) -# self.tree = self.create_tree() -# self.string = self.stringify() -# self.cacheable = cacheable if cacheable is not None else self.cacheable - -# def update( self, params ): -# assert all( [ -# type( self.query_params.get( key ) ) is type( params.get( key ) ) or params.get( key ) is None -# for key in self.query_params -# ] ), 'Types of values do not match' -# assert params != self.query_params, 'Params are unchanged' - -# self.query_params.update( params ) -# self.tree = self.create_tree() - -# def create_tree( self ): -# self.query_params.update( { -# 'children': self.components() -# } ) - -# if self.parent is None: -# return self.query_params.get( 'children' ) -# return self.parent( self.query_params ).tree - -# def stringify( self ): -# def recurse_nodes( node ): -# alias = node.get( 'alias' ) -# name = node.get( 'name' ) -# args = [] -# fields = [] -# if node.get( 'args' ): -# args = [ str( key ) + ': ' + str( value ) for key, value in node.get( 'args' ).items() ] -# if node.get( 'fields' ): -# fields = [ recurse_nodes( child ) for child in node.get( 'fields' ) ] - -# alias_str = alias + ': ' if alias else '' -# args_str = '(' + ', '.join( args ) + ')' if args else '' -# fields_str = '{' + ', '.join( fields ) + '}' if fields else '' - -# return alias_str + name + args_str + fields_str - -# return '{' + recurse_nodes( self.tree ) + '}' - -# def GQL_Type_Handler( argt, value ): -# if isinstance( argt, list ): -# return GQL_List( value, argt[ 0 ] ) -# return argt( value ) - -# class GQL_Type: -# def __init__( self, value ): -# self.value = value - -# class GQL_Boolean( GQL_Type ): -# def __str__( self ): -# return str( self.value and 'true' or 'false' ) - -# class GQL_String( GQL_Type ): -# def __str__( self ): -# return '"' + str( self.value ) + '"' - -# class GQL_Int( GQL_Type ): -# def __str__( self ): -# return str( self.value ) - -# class GQL_Float( GQL_Type ): -# def __str__( self ): -# return str( self.value ) - -# class GQL_Enum( GQL_Type ): -# allowed = [] - -# def __str__( self ): -# assert self.value in self.allowed, f'{self.value} not in Enum {self.__class__.__name__}' -# return self.value - -# class GQL_List( GQL_Type ): -# def __init__( self, value, secondaryType ): -# super().__init__( value ) -# self.secondaryType = secondaryType - -# def __str__( self ): -# assert self.secondaryType is not None, 'Secondary type is not defined for list object' -# assert isinstance( self.value, list ), 'Values are not a list' -# return '[' + ', '.join( [ str( self.secondaryType( val ) ) for val in self.value ] ) + ']' - -# # TODO: Generate this from GraphQL schema - -# class GQL_EventDataType( GQL_Enum ): -# allowed = [ -# 'All', -# 'Buffs', -# 'Casts', -# 'CombatantInfo', -# 'DamageDone', -# 'DamageTaken', -# 'Deaths', -# 'Debuffs', -# 'Dispels', -# 'Healing', -# 'Interrupts', -# 'Resources', -# 'Summons', -# 'Threat', -# ] - -# class ReportData( Query ): -# pass - -# class Report( Query ): -# parent = ReportData -# args = { -# 'code': GQL_String -# } - -# class PlayerDetails( Query ): -# parent = Report -# args = { -# 'difficulty': GQL_Int, -# 'encounterID': GQL_Int, -# 'endTime': GQL_Float, -# 'fightIDs': [ GQL_Int ], -# # 'killType': GQL_KillType, -# 'startTime': GQL_Float, -# 'translate': GQL_Boolean -# } - -# class MasterData( Query ): -# parent = Report -# args = { -# 'translate': GQL_Boolean -# } - -# class Actors( Query ): -# parent = MasterData -# args = { -# 'type': GQL_String, -# 'subType': GQL_String -# } - -# fields = [ 'gameID', 'icon', 'id', 'name', 'petOwner', 'server', 'subType', 'type' ] - -# class RateLimitData( Query ): -# pass - -# class PointsSpentThisHour( Query ): -# parent = RateLimitData -# cacheable = False - -# class Fights( Query ): -# parent = Report -# cacheable = False -# fields = [ 'id', 'encounterID', 'name', 'difficulty', 'kill', 'startTime', 'endTime' ] - -# class Events( Query ): -# parent = Report -# paginator = { -# 'paginationField': 'nextPageTimestamp', -# 'overrides': 'startTime' -# } - -# args = { -# 'abilityID': GQL_Float, -# 'dataType': GQL_EventDataType, -# 'death': GQL_Int, -# 'difficulty': GQL_Int, -# 'encounterID': GQL_Int, -# 'endTime': GQL_Float, -# 'fightIDs': [ GQL_Int ], -# 'filterExpression': GQL_String, -# # 'hostilityType': GQL_HostilityType, -# 'includeResources': GQL_Boolean, -# # 'killType': GQL_KillType, -# 'limit': GQL_Int, -# 'sourceAurasAbsent': GQL_String, -# 'sourceAurasPresent': GQL_String, -# 'sourceClass': GQL_String, -# 'sourceID': GQL_Int, -# 'sourceInstanceID': GQL_Int, -# 'startTime': GQL_Float, -# 'targetAurasAbsent': GQL_String, -# 'targetAurasPresent': GQL_String, -# 'targetClass': GQL_String, -# 'targetID': GQL_Int, -# 'targetInstanceID': GQL_Int, -# 'translate': GQL_Boolean, -# 'useAbilityIDs': GQL_Boolean, -# 'useActorIDs': GQL_Boolean, -# 'viewOptions': GQL_Int, -# 'wipeCutoff': GQL_Int -# } - -# fields = [ 'data' ] - -# class Reports( Query ): -# parent = ReportData -# paginator = { -# 'paginationField': 'current_page', -# 'overrides': 'page' -# } - -# args = { -# 'endTime': GQL_Float, -# 'guildID': GQL_Int, -# 'guildName': GQL_String, -# 'guildServerSlug': GQL_String, -# 'guildServerRegion': GQL_String, -# 'guildTagID': GQL_Int, -# 'userID': GQL_Int, -# 'limit': GQL_Int, -# 'page': GQL_Int, -# 'startTime': GQL_Float, -# 'zoneID': GQL_Int, -# 'gameZoneID': GQL_Int -# } - -# fields = [ -# 'data', -# 'total', -# 'per_page', -# 'current_page', -# 'from', -# 'to', -# 'last_page', -# 'has_more_pages' -# ] - -# # GQL 2.0 -# # object_name( {argument_key: argument_value, ...} ){ [field, ...] } - -# class GQL_OBJECT: -# # Provided by instantiator -# alias = None -# args = {} -# fields = {} - -# # Provided by code generation -# arg_types = {} -# field_types = {} -# name = None -# parent = None -# paginator = { -# 'field': None, -# 'replaces': None, -# 'callback': None -# } - -# def __init__( self, args, fields ): -# # Update name of child in fields and in the child object -# # children may have multiple parents, and be called different things by each -# if fields.get( 'child' ) is not None: -# expected_name = None -# child = fields[ 'child' ] -# for name, t in self.field_types.items(): -# if isinstance( child, t ): -# expected_name = name -# break -# if expected_name is not None: -# fields.update( { -# expected_name: child -# } ) -# fields[ expected_name ].name = expected_name -# fields.pop( 'child' ) - -# # Verify all arguments and fields are of the expected types -# assert all( [ -# isinstance( arg_v, expected_type ) -# for arg_k, arg_v in args.items() -# if ( expected_type := self.arg_types.get( arg_k ) ) -# ] ), f'Not all args are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{args}\n{self.arg_types}' -# assert all( [ -# isinstance( field_v, expected_type ) -# for field_k, field_v in fields.items() -# if ( expected_type := self.field_types.get( field_k ) ) -# ] ), f'Not all fields are for {self.__class__.__name__} ({self.name}) are of the expected type.\n{fields}\n{self.field_types}' - -# self.args = args -# self.fields = fields - -# def __str__( self ): -# args = [ -# f'{key}: {str( value )}' -# for key, value in self.args.items() -# if hasattr( value, '__str__' ) and key in self.arg_types.keys() -# ] # yapf: disable -# fields = [ -# f'{str( value )}' -# for key, value in self.fields.items() -# if hasattr( value, '__str__' ) and key in self.field_types.keys() -# ] # yapf: disable -# args_str = ( '(' if len( args ) > 0 else -# '' ) + ','.join( args ) + ( ')' if len( args ) > 0 else '' ) -# fields_str = ( '{' if len( fields ) > 0 else -# '' ) + ','.join( fields ) + ( '}' if len( fields ) > 0 else '' ) -# alias_str = self.alias + ': ' if self.alias is not None else '' -# return f'{alias_str}{self.name}{args_str}{fields_str}' - -# def tree( self ): -# if self.parent is not None: -# # print( f'creating {self.parent.__name__} with:\nargs: {self.args}\nfields: {self.fields | { "child": self }}') -# return self.parent( self.args, -# self.fields | { -# 'child': self -# } ).tree() -# return self - -# class GQL_SCALAR: -# def __init__( self, value ): -# self.value = value - -# def __str__( self ): -# return f'{self.value}' - -# class GQL_SCALAR_Boolean( GQL_SCALAR ): -# def __str__( self ): -# return f'{self.value and "true" or "false"}' - -# class GQL_SCALAR_Float( GQL_SCALAR ): -# pass - -# class GQL_SCALAR_Int( GQL_SCALAR ): -# pass - -# class GQL_SCALAR_String( GQL_SCALAR ): -# def __str__( self ): -# return f'"{self.value}"' - -# class GQL_ENUM: -# allowed = [] - -# def __init__( self, value ): -# self.value = value - -# def __str__( self ): -# assert self.value in self.allowed, f'{self.value} is not in Enum {self.__class__.__name__}.' -# return f'{self.value}' - -# # class GQL_OBJECT_( GQL_Object ): -# # def __init__( self, args, fields ): -# # self.arg_types = { -# # : GQL_, -# # ... -# # } -# # self.field_types = { -# # : GQL_, -# # ... -# # } -# # self.name = -# # self.parent = GQL_ -# # self.paginator = { -# # 'field': , -# # 'replaces': , -# # 'callback': -# # } -# # super().__init__( args, fields ) -# class GQL_Test1( GQL_OBJECT ): -# def __init__( self, args, fields ): -# self.name = 'test-one' -# self.field_types = { -# 'newname-two': GQL_Test2 -# } -# super().__init__( args, fields ) - -# class GQL_Test2( GQL_OBJECT ): -# def __init__( self, args, fields ): -# self.name = 'test-two' -# self.parent = GQL_Test1 -# super().__init__( args, fields ) - -""" -1. each object uses the canonical GQL typename as its name -2. each object contains two sets of references: args and fields -2. each reference contains GQL typename, local aliased name and metadata -""" -""" -BASE KINDS: -SCALAR, -OBJECT, -ENUM - -META KINDS: -NON_NULL, -LIST -""" -""" -META TYPE KINDS -""" - class GQL_KIND: def __init__( self, data ): self.data = data @@ -444,6 +19,9 @@ class GQL_ENUM( GQL_KIND ): def is_valid( self ): return self.data in self.enum_values +class GQL_OBJECT( GQL_KIND ): + pass + class GQL_NON_NULL( GQL_KIND ): def is_valid( self ): return isinstance( self.data, GQL_KIND ) and self.data.is_valid() @@ -454,83 +32,3 @@ def __str__( self ): def is_valid( self ): return isinstance( self.data, list ) and all( [ hasattr( datum, 'is_valid' ) and datum.is_valid() for datum in self.data ] ) # yapf: disable - -if __name__ == '__main__': - import json - from request import Request - - class SchemaIntrospection: - schema_location = 'wcl/introspection_query.json' - tree = { - 'name': '__schema' - } - paginator = {} - cacheable = True - - def __str__( self ): - with open( self.schema_location, 'r' ) as handle: - data = handle.read() - return data - - schema_query = SchemaIntrospection() - schema_request_data = Request( schema_query ).data - - tab = ' ' - objects = { - 'ENUM': [ -"""from query import GQL_ENUM - -\"\"\" -ENUM TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. -\"\"\"""" - ], - 'OBJECT': [ -"""from query import GQL_Object -import enum -import scalar - -\"\"\" -OBJECT TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. -\"\"\"""" - ] - } - - def handle_enum( entry ): - assert entry[ 'kind' ] == 'ENUM' - longest_str = max( [ len( enum_value[ 'name' ] ) for enum_value in entry[ 'enumValues' ] ] ) - lines = [ - f'class GQL_{entry["name"]}( GQL_ENUM ):', - f'{tab}enum_values = [', - *[ - f'{tab*2}\'{name}\',{" "*(longest_str-len(name))} # {desc}' - for enum_value in entry['enumValues'] - if ( name := enum_value['name'] ) - if ( desc := enum_value['description'] ) - ], - f'{tab}]' - ] # yapf: disable - return '\n'.join( lines ) - - def handle_object( entry ): - return "" - - for k in schema_request_data[ 'types' ]: - kind = k[ 'kind' ] - if kind in objects.keys(): - current = objects[ kind ] - match kind: - case 'ENUM': - current.append( handle_enum( k ) ) - case 'OBJECT': - current.append( handle_object( k ) ) - case _: - pass - - objects.update( { - kind: current - } ) - for kind, values in objects.items(): - with open( f'wcl/types/{kind.lower()}.py', 'w' ) as handle: - handle.write( '\n\n'.join( values ) ) diff --git a/wcl/types/__init__.py b/wcl/types/__init__.py new file mode 100644 index 0000000..97b89bd --- /dev/null +++ b/wcl/types/__init__.py @@ -0,0 +1,8 @@ +# from . import enum, object, scalar +from . import enum +from . import scalar +# from . import object + +""" +asdf +""" diff --git a/wcl/types/enum.py b/wcl/types/enum.py index f778b6e..4dc2b35 100644 --- a/wcl/types/enum.py +++ b/wcl/types/enum.py @@ -1,4 +1,4 @@ -from query import GQL_ENUM +from ..query import GQL_ENUM """ ENUM TYPES diff --git a/wcl/types/object.py b/wcl/types/object.py index 0f4acb7..98db19f 100644 --- a/wcl/types/object.py +++ b/wcl/types/object.py @@ -1,155 +1,4227 @@ -from query import GQL_Object -import enum -import scalar +from ..query import * +from .enum import * +from .scalar import * """ OBJECT TYPES THIS FILE IS GENERATED BY `wcl/query.py`. """ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +class GQL_Query( GQL_OBJECT ): + fields = [ + { + "name": "characterData", + "description": "Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.", + "type": "GQL_CharacterData", + }, + { + "name": "gameData", + "description": "Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..", + "type": "GQL_GameData", + }, + { + "name": "guildData", + "description": "Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.", + "type": "GQL_GuildData", + }, + { + "name": "progressRaceData", + "description": "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.", + "type": "GQL_ProgressRaceData", + }, + { + "name": "rateLimitData", + "description": "Obtain the rate limit data object to see how many points have been spent by this key.", + "type": "GQL_RateLimitData", + }, + { + "name": "reportData", + "description": "Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.", + "type": "GQL_ReportData", + }, + { + "name": "userData", + "description": "Obtain the user object that allows the retrieval of the authorized user's id and username.", + "type": "GQL_UserData", + }, + { + "name": "worldData", + "description": "Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon/raid zones, and encounters.", + "type": "GQL_WorldData", + }, + ] + +class GQL_CharacterData( GQL_OBJECT ): + fields = [ + { + "name": "character", + "description": "Obtain a specific character either by id or by name/server_slug/server_region.", + "type": "GQL_Character", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single character to retrieve.", + "type": GQL_Int, + }, + { + "name": "name", + "description": "Optional. The name of a specific character. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a character.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The slug of a specific server. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": GQL_String, + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific character. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": GQL_String, + }, + ] + }, + { + "name": "characters", + "description": "A collection of characters for a specific guild.", + "type": "GQL_CharacterPagination", + "args": [ + { + "name": "guildID", + "description": "Required. The ID of a specific guild. Characters from that guild will be fetched.", + "type": GQL_Int, + }, + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_Character( GQL_OBJECT ): + fields = [ + { + "name": "canonicalID", + "description": "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.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "claimed", + "description": "Whether this character is claimed by the current user. Only accessible if accessed via the user API with the "view-user-profile" scope.", + "type": GQL_Boolean, + }, + { + "name": "classID", + "description": "The class id of the character.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "encounterRankings", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "byBracket", + "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": GQL_Boolean, + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": GQL_String, + }, + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": GQL_RankingCompareType, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Required. The specific encounter whose rankings should be fetched.", + "type": GQL_Int, + }, + { + "name": "includeCombatantInfo", + "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": GQL_Boolean, + }, + { + "name": "includePrivateLogs", + "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": GQL_Boolean, + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": GQL_CharacterRankingMetricType, + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": GQL_Int, + }, + { + "name": "role", + "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": GQL_RoleType, + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": GQL_Int, + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": GQL_String, + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": GQL_RankingTimeframeType, + }, + ] + }, + { + "name": "faction", + "description": "The faction of the character.", + "type": GQL_NON_NULL("GQL_GameFaction"), + }, + { + "name": "gameData", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "specID", + "description": "Optional. A specific spec ID to retrieve information for. If omitted, the last observed spec on Armory (WoW) or Lodestone (FF) will be used.", + "type": GQL_Int, + }, + { + "name": "forceUpdate", + "description": "Optional. Whether or not to force the updating of the character before returning the game data.", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "guildRank", + "description": "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.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "guilds", + "description": "All guilds that the character belongs to.", + "type": GQL_LIST("GQL_Guild"), + }, + { + "name": "hidden", + "description": "Whether or not the character has all its rankings hidden.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "id", + "description": "The ID of the character.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "level", + "description": "The level of the character.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The name of the character.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "recentReports", + "description": "Recent reports for the character.", + "type": "GQL_ReportPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of recent reports to retrieve. If omitted, defaults to 10. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "server", + "description": "The server that the character belongs to.", + "type": GQL_NON_NULL("GQL_Server"), + }, + { + "name": "zoneRankings", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "byBracket", + "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": GQL_Boolean, + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": GQL_String, + }, + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": GQL_RankingCompareType, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": GQL_Int, + }, + { + "name": "includePrivateLogs", + "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": GQL_Boolean, + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": GQL_CharacterRankingMetricType, + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": GQL_Int, + }, + { + "name": "role", + "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": GQL_RoleType, + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": GQL_Int, + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": GQL_String, + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": GQL_RankingTimeframeType, + }, + { + "name": "zoneID", + "description": "Optional. If not specified, the latest unfrozen zone will be used.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_GameFaction( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "An integer representing the faction id.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the faction.", + "type": GQL_NON_NULL(GQL_String), + }, + ] + +class GQL_Guild( GQL_OBJECT ): + fields = [ + { + "name": "attendance", + "description": "None", + "type": GQL_NON_NULL("GQL_GuildAttendancePagination"), + "args": [ + { + "name": "guildTagID", + "description": "Optional. Whether or not to filter the attendance to a specific guild tag.", + "type": GQL_Int, + }, + { + "name": "limit", + "description": "Optional. The number of reports to retrieve per page. If omitted, defaults to 16. The maximum allowed value is 25, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + { + "name": "zoneID", + "description": "Optional. Whether or not to filter the attendance table to a specific zone.", + "type": GQL_Int, + }, + ] + }, + { + "name": "competitionMode", + "description": "Whether or not the guild has competition mode enabled.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "description", + "description": "The description for the guild that is displayed with the guild name on the site.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "faction", + "description": "The faction of the guild.", + "type": GQL_NON_NULL("GQL_GameFaction"), + }, + { + "name": "id", + "description": "The ID of the guild.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The name of the guild.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "server", + "description": "The server that the guild belongs to.", + "type": GQL_NON_NULL("GQL_Server"), + }, + { + "name": "stealthMode", + "description": "Whether or not the guild has stealth mode enabled.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "tags", + "description": "The tags used to label reports. In the site UI, these are called raid teams.", + "type": GQL_LIST("GQL_GuildTag"), + }, + { + "name": "members", + "description": "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.", + "type": GQL_NON_NULL("GQL_CharacterPagination"), + "args": [ + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "currentUserRank", + "description": "The current user's rank within the guild. Only accessible via user authentication with the "view-user-profile" scope.", + "type": GQL_GuildRank, + }, + { + "name": "zoneRanking", + "description": "The guild's ranking for a zone. If `zoneId` is unset or null, uses the latest zone.", + "type": GQL_NON_NULL("GQL_GuildZoneRankings"), + "args": [ + { + "name": "zoneId", + "description": "None", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_GuildAttendancePagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GuildAttendance"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GuildAttendance( GQL_OBJECT ): + fields = [ + { + "name": "code", + "description": "The code of the report for the raid night.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "players", + "description": "The players that attended that raid night.", + "type": GQL_LIST("GQL_PlayerAttendance"), + }, + { + "name": "startTime", + "description": "The start time of the raid night.", + "type": GQL_Float, + }, + { + "name": "zone", + "description": "The principal zone of the raid night.", + "type": "GQL_Zone", + }, + ] + +class GQL_PlayerAttendance( GQL_OBJECT ): + fields = [ + { + "name": "name", + "description": "The name of the player.", + "type": GQL_String, + }, + { + "name": "type", + "description": "The class of the player.", + "type": GQL_String, + }, + { + "name": "presence", + "description": "Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.", + "type": GQL_Int, + }, + ] + +class GQL_Zone( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the zone.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "brackets", + "description": "The bracket information for this zone. This field will be null if the zone does not support brackets.", + "type": "GQL_Bracket", + }, + { + "name": "difficulties", + "description": "A list of all the difficulties supported for this zone.", + "type": GQL_LIST("GQL_Difficulty"), + }, + { + "name": "encounters", + "description": "The encounters found within this zone.", + "type": GQL_LIST("GQL_Encounter"), + }, + { + "name": "expansion", + "description": "The expansion that this zone belongs to.", + "type": GQL_NON_NULL("GQL_Expansion"), + }, + { + "name": "frozen", + "description": "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.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "name", + "description": "The name of the zone.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "partitions", + "description": "A list of all the partitions supported for this zone.", + "type": GQL_LIST("GQL_Partition"), + }, + ] + +class GQL_Bracket( GQL_OBJECT ): + fields = [ + { + "name": "min", + "description": "An integer representing the minimum value used by bracket number 1, etc.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "max", + "description": "An integer representing the value used by bracket N when there are a total of N brackets, etc.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "bucket", + "description": "A float representing the value to increment when moving from bracket 1 to bracket N, etc.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "type", + "description": "The localized name of the bracket type.", + "type": GQL_String, + }, + ] + +class GQL_Difficulty( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "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.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name for the difficulty level.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "sizes", + "description": "A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.", + "type": GQL_LIST(GQL_Int), + }, + ] + +class GQL_Encounter( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the encounter.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the encounter.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "characterRankings", + "description": "Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "type": GQL_JSON, + "args": [ + { + "name": "bracket", + "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": GQL_Int, + }, + { + "name": "filter", + "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": GQL_String, + }, + { + "name": "page", + "description": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": GQL_Int, + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": GQL_Int, + }, + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": GQL_String, + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": GQL_Int, + }, + { + "name": "leaderboard", + "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": GQL_LeaderboardRank, + }, + { + "name": "hardModeLevel", + "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": GQL_HardModeLevelRankFilter, + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific player metric like dps or hps. If omitted, an appropriate default player metric for the zone will be chosen.", + "type": GQL_CharacterRankingMetricType, + }, + { + "name": "includeCombatantInfo", + "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": GQL_Boolean, + }, + { + "name": "className", + "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. If omitted, data for all classes will be used.", + "type": GQL_String, + }, + { + "name": "specName", + "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": GQL_String, + }, + { + "name": "externalBuffs", + "description": "Optional. Controls whether to include ranks with/without external buffs. Most games and zones do not support this filter and will quietly ignore it.", + "type": GQL_ExternalBuffRankFilter, + }, + { + "name": "covenantID", + "description": "Optional. The covenant ID to filter to if viewing Shadowlands rankings.", + "type": GQL_Int, + }, + { + "name": "soulbindID", + "description": "Optional. The soulbind ID to filter to if viewing Shadowlands rankings.", + "type": GQL_Int, + }, + ] + }, + { + "name": "fightRankings", + "description": "Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "type": GQL_JSON, + "args": [ + { + "name": "bracket", + "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": GQL_Int, + }, + { + "name": "filter", + "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": GQL_String, + }, + { + "name": "page", + "description": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": GQL_Int, + }, + { + "name": "partition", + "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": GQL_Int, + }, + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": GQL_String, + }, + { + "name": "size", + "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": GQL_Int, + }, + { + "name": "leaderboard", + "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": GQL_LeaderboardRank, + }, + { + "name": "hardModeLevel", + "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": GQL_HardModeLevelRankFilter, + }, + { + "name": "metric", + "description": "Optional. You can filter to a specific fight metric like speed or execution. If omitted, an appropriate default fight metric for the zone will be chosen.", + "type": GQL_FightRankingMetricType, + }, + ] + }, + { + "name": "zone", + "description": "The zone that this encounter is found in.", + "type": GQL_NON_NULL("GQL_Zone"), + }, + { + "name": "journalID", + "description": "The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_Expansion( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the expansion.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the expansion.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "zones", + "description": "The zones (e.g., raids and dungeons) supported for this expansion.", + "type": GQL_LIST("GQL_Zone"), + }, + ] + +class GQL_Partition( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "An integer representing a specific partition within a zone.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name for partition.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "compactName", + "description": "The compact localized name for the partition. Typically an abbreviation to conserve space.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "default", + "description": "Whether or not the partition is the current default when viewing rankings or statistics for the zone.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_Server( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the server.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The name of the server in the locale of the subregion that the server belongs to.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "normalizedName", + "description": "The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "slug", + "description": "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.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "region", + "description": "The region that this server belongs to.", + "type": GQL_NON_NULL("GQL_Region"), + }, + { + "name": "subregion", + "description": "The subregion that this server belongs to.", + "type": GQL_NON_NULL("GQL_Subregion"), + }, + { + "name": "guilds", + "description": "The guilds found on this server (and any servers connected to this one.", + "type": "GQL_GuildPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of guilds to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "characters", + "description": "The characters found on this server (and any servers connected to this one.", + "type": "GQL_CharacterPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_Region( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the region.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "compactName", + "description": "The localized compact name of the region, e.g., US for United States.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "name", + "description": "The localized name of the region.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "slug", + "description": "The slug for the region, usable when looking up characters and guilds by server.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "subregions", + "description": "The subregions found within this region.", + "type": GQL_LIST("GQL_Subregion"), + }, + { + "name": "servers", + "description": "The servers found within this region.", + "type": "GQL_ServerPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_Subregion( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the subregion.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the subregion.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "region", + "description": "The region that this subregion is found in.", + "type": GQL_NON_NULL("GQL_Region"), + }, + { + "name": "servers", + "description": "The servers found within this region.", + "type": "GQL_ServerPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_ServerPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_Server"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GuildPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_Guild"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_CharacterPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_Character"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GuildTag( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the tag.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "guild", + "description": "The guild that the tag belongs to.", + "type": GQL_NON_NULL("GQL_Guild"), + }, + { + "name": "name", + "description": "The name of the tag.", + "type": GQL_NON_NULL(GQL_String), + }, + ] + +class GQL_GuildZoneRankings( GQL_OBJECT ): + fields = [ + { + "name": "progress", + "description": "The progress ranks for the guild. Always uses the highest difficulty.", + "type": "GQL_WorldRegionServerRankPositions", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": GQL_Int, + }, + ] + }, + { + "name": "speed", + "description": "The all-star based speed rank for the guild.", + "type": "GQL_WorldRegionServerRankPositions", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Raid difficulty.", + "type": GQL_Int, + }, + ] + }, + { + "name": "completeRaidSpeed", + "description": "The complete raid speed ranks for the guild. Most non-Classic WoW zones do not support complete raid ranks.", + "type": "GQL_WorldRegionServerRankPositions", + "args": [ + { + "name": "size", + "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Raid difficulty.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_WorldRegionServerRankPositions( GQL_OBJECT ): + fields = [ + { + "name": "worldRank", + "description": "None", + "type": "GQL_Rank", + }, + { + "name": "regionRank", + "description": "None", + "type": "GQL_Rank", + }, + { + "name": "serverRank", + "description": "None", + "type": "GQL_Rank", + }, + ] + +class GQL_Rank( GQL_OBJECT ): + fields = [ + { + "name": "number", + "description": "The ordinal rank (usually written "Rank N"). Rank 1 = highest.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "percentile", + "description": "The percentile of the rank as an integer in [0, 100]. Always null for guild ranks.", + "type": GQL_Int, + }, + { + "name": "color", + "description": "The color class used by the site for this rank.", + "type": GQL_NON_NULL(GQL_String), + }, + ] + +class GQL_ReportPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_Report"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_Report( GQL_OBJECT ): + fields = [ + { + "name": "code", + "description": "The report code, a unique value used to identify the report.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "endTime", + "description": "The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "events", + "description": "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.", + "type": "GQL_ReportEventPaginator", + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": GQL_Float, + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": GQL_EventDataType, + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": GQL_String, + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": GQL_HostilityType, + }, + { + "name": "includeResources", + "description": "Optional. Whether or not to include detailed unit resources for actors. Adds substantially to bandwidth, so defaults to off.", + "type": GQL_Boolean, + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": GQL_KillType, + }, + { + "name": "limit", + "description": "Optional. How many events to retrieve. Allowed value ranges are 100-10000. The default value is 300.", + "type": GQL_Int, + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": GQL_Int, + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": GQL_Int, + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if is a priority, and you do not care about the names.", + "type": GQL_Boolean, + }, + { + "name": "useAbilityIDs", + "description": "Optional. Whether or not to include detailed ability information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": GQL_Boolean, + }, + { + "name": "useActorIDs", + "description": "Optional. Whether or not to include detailed actor information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": GQL_Boolean, + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": GQL_Int, + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": GQL_Int, + }, + ] + }, + { + "name": "exportedSegments", + "description": "The number of exported segments in the report. This is how many segments have been processed for rankings.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "fights", + "description": "A set of fights with details about participating players.", + "type": GQL_LIST("GQL_ReportFight"), + "args": [ + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": GQL_KillType, + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "graph", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": GQL_Float, + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": GQL_GraphDataType, + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": GQL_String, + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": GQL_HostilityType, + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": GQL_KillType, + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": GQL_Int, + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": GQL_Int, + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": GQL_Boolean, + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": GQL_Int, + }, + { + "name": "viewBy", + "description": "Optional. Whether to view by source, by target or by ability.", + "type": GQL_ViewType, + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": GQL_Int, + }, + ] + }, + { + "name": "guild", + "description": "The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.", + "type": "GQL_Guild", + }, + { + "name": "guildTag", + "description": "The guild tag that the report belongs to. If this is null, then the report was not tagged.", + "type": "GQL_GuildTag", + }, + { + "name": "owner", + "description": "The user that uploaded the report.", + "type": "GQL_User", + }, + { + "name": "masterData", + "description": "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.", + "type": "GQL_ReportMasterData", + "args": [ + { + "name": "translate", + "description": "Optional. Whether or not the actors and abilities in the master data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names of abilities and actors.", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "playerDetails", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": GQL_KillType, + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "rankedCharacters", + "description": "A list of all characters that ranked on kills in the report.", + "type": GQL_LIST("GQL_Character"), + }, + { + "name": "rankings", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "compare", + "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": GQL_RankingCompareType, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "playerMetric", + "description": "Optional. You can filter to a specific player metric like dps or hps.", + "type": GQL_ReportRankingMetricType, + }, + { + "name": "timeframe", + "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": GQL_RankingTimeframeType, + }, + ] + }, + { + "name": "region", + "description": "The region of the report.", + "type": "GQL_Region", + }, + { + "name": "revision", + "description": "The revision of the report. This number is increased when reports get re-exported.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "segments", + "description": "The number of uploaded segments in the report.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "startTime", + "description": "The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "table", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "abilityID", + "description": "Optional. The game id of a specific ability to filter to.", + "type": GQL_Float, + }, + { + "name": "dataType", + "description": "Optional. You can filter to a specific subset of events.", + "type": GQL_TableDataType, + }, + { + "name": "death", + "description": "Optional. If viewing death events, a specific death to obtain information for.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "encounterID", + "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": GQL_Int, + }, + { + "name": "endTime", + "description": "Optional. The end time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "fightIDs", + "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "filterExpression", + "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": GQL_String, + }, + { + "name": "hostilityType", + "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": GQL_HostilityType, + }, + { + "name": "killType", + "description": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": GQL_KillType, + }, + { + "name": "sourceAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceAurasPresent", + "description": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": GQL_String, + }, + { + "name": "sourceClass", + "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "sourceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": GQL_Int, + }, + { + "name": "sourceInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "startTime", + "description": "Optional. The start time of the events range to fetch.", + "type": GQL_Float, + }, + { + "name": "targetAurasAbsent", + "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetAurasPresent", + "description": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": GQL_String, + }, + { + "name": "targetClass", + "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": GQL_String, + }, + { + "name": "targetID", + "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": GQL_Int, + }, + { + "name": "targetInstanceID", + "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": GQL_Int, + }, + { + "name": "translate", + "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": GQL_Boolean, + }, + { + "name": "viewOptions", + "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": GQL_Int, + }, + { + "name": "viewBy", + "description": "Optional. Whether to view by source, by target or by ability.", + "type": GQL_ViewType, + }, + { + "name": "wipeCutoff", + "description": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": GQL_Int, + }, + ] + }, + { + "name": "title", + "description": "A title for the report.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "visibility", + "description": "The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "zone", + "description": "The principal zone that the report contains fights for. Null if no supported zone exists.", + "type": "GQL_Zone", + }, + { + "name": "archiveStatus", + "description": "Whether this report has been archived. Events, tables, and graphs for archived reports are inaccessible unless the retrieving user has a subscription including archive access.", + "type": "GQL_ReportArchiveStatus", + }, + { + "name": "phases", + "description": "Phase information for all boss encounters observed in this report. This requires loading fight data, but does not double-charge API points if you load fights and phases.", + "type": GQL_LIST(GQL_NON_NULL("GQL_EncounterPhases")), + }, + ] + +class GQL_ReportEventPaginator( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "The list of events obtained.", + "type": GQL_JSON, + }, + { + "name": "nextPageTimestamp", + "description": "A timestamp to pass in as the start time when fetching the next page of data.", + "type": GQL_Float, + }, + ] + +class GQL_ReportFight( GQL_OBJECT ): + fields = [ + { + "name": "averageItemLevel", + "description": "The average item level of the players in the fight.", + "type": GQL_Float, + }, + { + "name": "bossPercentage", + "description": "The percentage health of the active boss or bosses at the end of a fight.", + "type": GQL_Float, + }, + { + "name": "boundingBox", + "description": "The bounding box that encloses the positions of all players/enemies in the fight.", + "type": "GQL_ReportMapBoundingBox", + }, + { + "name": "classicSeasonID", + "description": "The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.", + "type": GQL_Int, + }, + { + "name": "completeRaid", + "description": "Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "difficulty", + "description": "The difficulty setting for the raid, dungeon, or arena. Null for trash.", + "type": GQL_Int, + }, + { + "name": "dungeonPulls", + "description": "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.", + "type": GQL_LIST("GQL_ReportDungeonPull"), + }, + { + "name": "encounterID", + "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "endTime", + "description": "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.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "enemyNPCs", + "description": "Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": GQL_LIST("GQL_ReportFightNPC"), + }, + { + "name": "enemyPets", + "description": "Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "type": GQL_LIST("GQL_ReportFightNPC"), + }, + { + "name": "enemyPlayers", + "description": "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.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "fightPercentage", + "description": "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.", + "type": GQL_Float, + }, + { + "name": "friendlyNPCs", + "description": "Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": GQL_LIST("GQL_ReportFightNPC"), + }, + { + "name": "friendlyPets", + "description": "Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "type": GQL_LIST("GQL_ReportFightNPC"), + }, + { + "name": "friendlyPlayers", + "description": "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.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "gameZone", + "description": "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.", + "type": "GQL_GameZone", + }, + { + "name": "hardModeLevel", + "description": "The hard mode level of the fight. Most fights don't support optional hard modes. This only applies to bosses like Sartharion.", + "type": GQL_Int, + }, + { + "name": "id", + "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "inProgress", + "description": "Whether or not the fight is still in progress. If this field is false, it means the entire fight has been uploaded.", + "type": GQL_Boolean, + }, + { + "name": "keystoneAffixes", + "description": "The affixes for a Mythic+ dungeon.", + "type": GQL_LIST(GQL_Int), + }, + { + "name": "keystoneBonus", + "description": "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.", + "type": GQL_Int, + }, + { + "name": "keystoneLevel", + "description": "The keystone level for a Mythic+ dungeon.", + "type": GQL_Int, + }, + { + "name": "keystoneTime", + "description": "The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.", + "type": GQL_Int, + }, + { + "name": "kill", + "description": "Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was a wipe or a failed run, etc..", + "type": GQL_Boolean, + }, + { + "name": "lastPhase", + "description": "The phase that the encounter was in when the fight ended. Counts up from 1 based off the phase type (i.e., normal phase vs intermission).", + "type": GQL_Int, + }, + { + "name": "lastPhaseAsAbsoluteIndex", + "description": "The phase that the encounter was in when the fight ended. Always increases from 0, so a fight with three real phases and two intermissions would count up from 0 to 4.", + "type": GQL_Int, + }, + { + "name": "lastPhaseIsIntermission", + "description": "Whether or not the phase that the encounter was in when the fight ended was an intermission or not.", + "type": GQL_Boolean, + }, + { + "name": "layer", + "description": "The layer of a Torghast run.", + "type": GQL_Int, + }, + { + "name": "maps", + "description": "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.", + "type": GQL_LIST("GQL_ReportMap"), + }, + { + "name": "name", + "description": "The name of the fight.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "originalEncounterID", + "description": "Some boss fights may be converted to trash fights (encounterID = 0). When this occurs, `originalEncounterID` contains the original ID of the encounter.", + "type": GQL_Int, + }, + { + "name": "phaseTransitions", + "description": "List of observed phase transitions during the fight.", + "type": GQL_LIST(GQL_NON_NULL("GQL_PhaseTransition")), + }, + { + "name": "rating", + "description": "The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.", + "type": GQL_Int, + }, + { + "name": "size", + "description": "The group size for the raid, dungeon, or arena. Null for trash.", + "type": GQL_Int, + }, + { + "name": "startTime", + "description": "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.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "talentImportCode", + "description": "The import/export code for a Retail Dragonflight talent build. Will be null for a classic or pre-Dragonflight fight.", + "type": GQL_String, + "args": [ + { + "name": "actorID", + "description": "The friendly player actor to generate talents for. Result will be null for unknown or non-player actors. Use the ReportMasterData or the friendlyPlayers field on this type to get the list of friendly player actor IDs.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + }, + { + "name": "wipeCalledTime", + "description": "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.", + "type": GQL_Float, + }, + ] + +class GQL_ReportMapBoundingBox( GQL_OBJECT ): + fields = [ + { + "name": "minX", + "description": "The smallest X position.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "maxX", + "description": "The largest X position.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "minY", + "description": "The smallest Y position.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "maxY", + "description": "The largest Y position.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_ReportDungeonPull( GQL_OBJECT ): + fields = [ + { + "name": "boundingBox", + "description": "The bounding box that encloses the positions of all players/enemies in the fight.", + "type": "GQL_ReportMapBoundingBox", + }, + { + "name": "encounterID", + "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "endTime", + "description": "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.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "enemyNPCs", + "description": "Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": GQL_LIST("GQL_ReportDungeonPullNPC"), + }, + { + "name": "id", + "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "kill", + "description": "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..", + "type": GQL_Boolean, + }, + { + "name": "maps", + "description": "All the maps that were involved in a pull.", + "type": GQL_LIST("GQL_ReportMap"), + }, + { + "name": "name", + "description": "The name of the fight.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "startTime", + "description": "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.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "x", + "description": "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.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "y", + "description": "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.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_ReportDungeonPullNPC( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": GQL_Int, + }, + { + "name": "gameID", + "description": "The game ID of the actor, e.g., so it can be looked up on external Web sites.", + "type": GQL_Int, + }, + { + "name": "minimumInstanceID", + "description": "The lowest instance ID seen during the pull.", + "type": GQL_Int, + }, + { + "name": "maximumInstanceID", + "description": "The highest instance ID seen during the pull.", + "type": GQL_Int, + }, + { + "name": "minimumInstanceGroupID", + "description": "The lowest instance group ID seen during the pull.", + "type": GQL_Int, + }, + { + "name": "maximumInstanceGroupID", + "description": "The highest instance group ID seen during the pull.", + "type": GQL_Int, + }, + ] + +class GQL_ReportMap( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The map's game ID.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_ReportFightNPC( GQL_OBJECT ): + fields = [ + { + "name": "gameID", + "description": "The game ID of the actor. This ID is used in events to identify sources and targets.", + "type": GQL_Int, + }, + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": GQL_Int, + }, + { + "name": "instanceCount", + "description": "How many instances of the NPC were seen during the fight.", + "type": GQL_Int, + }, + { + "name": "groupCount", + "description": "How many packs of the NPC were seen during the fight.", + "type": GQL_Int, + }, + { + "name": "petOwner", + "description": "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.", + "type": GQL_Int, + }, + ] + +class GQL_GameZone( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the zone.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "name", + "description": "The localized name of the zone. Will be null if no localization information exists for the zone.", + "type": GQL_String, + }, + ] + +class GQL_PhaseTransition( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The 1-indexed id of the phase. Phase IDs are absolute within a fight: phases with the same ID correspond to the same semantic phase.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "startTime", + "description": "The report-relative timestamp of the transition into the phase. The phase ends at the beginning of the next phase, or at the end of the fight.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_User( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the user.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The name of the user.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "guilds", + "description": "The list of guilds to which the user belongs. Only accessible via user authentication when you have the "view-user-profile" scope.", + "type": GQL_LIST("GQL_Guild"), + }, + { + "name": "characters", + "description": "The characters claimed by this user. Only accessible via user authentication when you have the "view-user-profile" scope.", + "type": GQL_LIST("GQL_Character"), + }, + { + "name": "battleTag", + "description": "The battle tag of the user if they have linked it.", + "type": GQL_String, + }, + ] + +class GQL_ReportMasterData( GQL_OBJECT ): + fields = [ + { + "name": "logVersion", + "description": "The version of the client parser that was used to parse and upload this log file.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "gameVersion", + "description": "The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.", + "type": GQL_Int, + }, + { + "name": "lang", + "description": "The auto-detected locale of the report. This is the source language of the original log file.", + "type": GQL_String, + }, + { + "name": "abilities", + "description": "A list of every ability that occurs in the report.", + "type": GQL_LIST("GQL_ReportAbility"), + }, + { + "name": "actors", + "description": "A list of every actor (player, NPC, pet) that occurs in the report.", + "type": GQL_LIST("GQL_ReportActor"), + "args": [ + { + "name": "type", + "description": "Optional. A filter on the actors in a report. If the type field of the actor matches the specified type field, it will be included.", + "type": GQL_String, + }, + { + "name": "subType", + "description": "Optional. A filter on the actors in a report. If the subType field of the actor matches the specified subType field, it will be included.", + "type": GQL_String, + }, + ] + }, + ] + +class GQL_ReportAbility( GQL_OBJECT ): + fields = [ + { + "name": "gameID", + "description": "The game ID of the ability.", + "type": GQL_Float, + }, + { + "name": "icon", + "description": "An icon to use for the ability.", + "type": GQL_String, + }, + { + "name": "name", + "description": "The name of the actor.", + "type": GQL_String, + }, + { + "name": "type", + "description": "The type of the ability. This represents the type of damage (e.g., the spell school in WoW).", + "type": GQL_String, + }, + ] + +class GQL_ReportActor( GQL_OBJECT ): + fields = [ + { + "name": "gameID", + "description": "The game ID of the actor.", + "type": GQL_Float, + }, + { + "name": "icon", + "description": "An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.", + "type": GQL_String, + }, + { + "name": "id", + "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": GQL_Int, + }, + { + "name": "name", + "description": "The name of the actor.", + "type": GQL_String, + }, + { + "name": "petOwner", + "description": "The report ID of the actor's owner if the actor is a pet.", + "type": GQL_Int, + }, + { + "name": "server", + "description": "The normalized server name of the actor.", + "type": GQL_String, + }, + { + "name": "subType", + "description": "The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.", + "type": GQL_String, + }, + { + "name": "type", + "description": "The type of the actor, i.e., if it is a player, pet or NPC.", + "type": GQL_String, + }, + ] + +class GQL_ReportArchiveStatus( GQL_OBJECT ): + fields = [ + { + "name": "isArchived", + "description": "Whether the report has been archived.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "isAccessible", + "description": "Whether the current user can access the report. Always true if the report is not archived, and always false if not using user authentication.", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "archiveDate", + "description": "The date on which the report was archived (if it has been archived).", + "type": GQL_Int, + }, + ] + +class GQL_EncounterPhases( GQL_OBJECT ): + fields = [ + { + "name": "encounterID", + "description": "None", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "separatesWipes", + "description": "Whether the phases can be used to separate wipes in the report UI.", + "type": GQL_Boolean, + }, + { + "name": "phases", + "description": "Phase metadata for all phases in this encounter.", + "type": GQL_LIST(GQL_NON_NULL("GQL_PhaseMetadata")), + }, + ] + +class GQL_PhaseMetadata( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "Phase ID. 1-indexed", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "None", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "isIntermission", + "description": "Whether this phase represents an intermission.", + "type": GQL_Boolean, + }, + ] + +class GQL_GameData( GQL_OBJECT ): + fields = [ + { + "name": "abilities", + "description": "The player and enemy abilities for the game.", + "type": "GQL_GameAbilityPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of abilities to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "ability", + "description": "Obtain a single ability for the game.", + "type": "GQL_GameAbility", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific ability to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "achievement", + "description": "Obtain a single achievement for the game.", + "type": "GQL_GameAchievement", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific achievement to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "achievements", + "description": "Achievements for the game.", + "type": "GQL_GameAchievementPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of achievements to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "affix", + "description": "Obtain a single affix for the game.", + "type": "GQL_GameAffix", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific affix to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "affixes", + "description": "The affixes for the game.", + "type": GQL_LIST("GQL_GameAffix"), + }, + { + "name": "class", + "description": "Obtain a single class for the game.", + "type": "GQL_GameClass", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific class to retrieve by its id.", + "type": GQL_Int, + }, + { + "name": "faction_id", + "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": GQL_Int, + }, + { + "name": "zone_id", + "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": GQL_Int, + }, + ] + }, + { + "name": "classes", + "description": "Obtain the supported classes for the game.", + "type": GQL_LIST("GQL_GameClass"), + "args": [ + { + "name": "faction_id", + "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": GQL_Int, + }, + { + "name": "zone_id", + "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": GQL_Int, + }, + ] + }, + { + "name": "enchant", + "description": "Obtain a single enchant for the game.", + "type": "GQL_GameEnchant", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific enchant to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "enchants", + "description": "Enchants for the game.", + "type": "GQL_GameEnchantPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of enchants to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "factions", + "description": "Obtain all the factions that guilds and players can belong to.", + "type": GQL_LIST("GQL_GameFaction"), + }, + { + "name": "item", + "description": "Obtain a single item for the game.", + "type": "GQL_GameItem", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific item to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "item_set", + "description": "Obtain a single item set for the game.", + "type": "GQL_GameItemSet", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific item set to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "item_sets", + "description": "Item sets for the game.", + "type": "GQL_GameItemSetPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of item sets to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "items", + "description": "Items for the game.", + "type": "GQL_GameItemPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of items to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "map", + "description": "Obtain a single map for the game.", + "type": "GQL_GameMap", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific map to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "maps", + "description": "Maps for the game.", + "type": "GQL_GameMapPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of maps to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "npc", + "description": "Obtain a single NPC for the game.", + "type": "GQL_GameNPC", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific NPC to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "npcs", + "description": "NPCs for the game.", + "type": "GQL_GameNPCPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of NPCs to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + { + "name": "zone", + "description": "Obtain a single zone for the game, not to be confused with the worldData zones for ranking bosses and dungeons.", + "type": "GQL_GameZone", + "args": [ + { + "name": "id", + "description": "Required. Specify a specific game zone to retrieve by its id.", + "type": GQL_Int, + }, + ] + }, + { + "name": "zones", + "description": "Zones for the game.", + "type": "GQL_GameZonePagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of game zones to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_GameAbilityPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameAbility"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameAbility( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the ability.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "icon", + "description": "The icon for the ability.", + "type": GQL_String, + }, + { + "name": "name", + "description": "The localized name of the ability. Will be null if no localization information exists for the ability.", + "type": GQL_String, + }, + ] + +class GQL_GameAchievement( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the achievement.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "icon", + "description": "The icon for the achievement.", + "type": GQL_String, + }, + { + "name": "name", + "description": "The localized name of the achievement. Will be null if no localization information exists for the achievement.", + "type": GQL_String, + }, + ] + +class GQL_GameAchievementPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameAchievement"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameAffix( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the affix.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "icon", + "description": "The icon for the affix.", + "type": GQL_String, + }, + { + "name": "name", + "description": "The localized name of the affix. Will be null if no localization information exists for the affix.", + "type": GQL_String, + }, + ] + +class GQL_GameClass( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "An integer used to identify the class.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the class.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "slug", + "description": "A slug used to identify the class.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "specs", + "description": "The specs supported by the class.", + "type": GQL_LIST("GQL_GameSpec"), + }, + ] + +class GQL_GameSpec( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "An integer used to identify the spec.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "class", + "description": "The player class that the spec belongs to.", + "type": "GQL_GameClass", + }, + { + "name": "name", + "description": "The localized name of the class.", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "slug", + "description": "A slug used to identify the spec.", + "type": GQL_NON_NULL(GQL_String), + }, + ] + +class GQL_GameEnchant( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the enchant.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the enchant. Will be null if no localization information exists for the enchant.", + "type": GQL_String, + }, + ] + +class GQL_GameEnchantPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameEnchant"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameItem( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the item.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "icon", + "description": "The icon for the item.", + "type": GQL_String, + }, + { + "name": "name", + "description": "The localized name of the item. Will be null if no localization information exists for the item.", + "type": GQL_String, + }, + ] + +class GQL_GameItemSet( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the item set.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the item set. Will be null if no localization information exists for the item set.", + "type": GQL_String, + }, + ] + +class GQL_GameItemSetPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameItemSet"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameItemPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameItem"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameMap( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the map.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the map. Will be null if no localization information exists for the map.", + "type": GQL_String, + }, + ] + +class GQL_GameMapPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameMap"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameNPC( GQL_OBJECT ): + fields = [ + { + "name": "id", + "description": "The ID of the NPC.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "name", + "description": "The localized name of the NPC. Will be null if no localization information exists for the NPC.", + "type": GQL_String, + }, + ] + +class GQL_GameNPCPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameNPC"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GameZonePagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "description": "List of items on the current page", + "type": GQL_LIST("GQL_GameZone"), + }, + { + "name": "total", + "description": "Number of total items selected by the query", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "per_page", + "description": "Number of items returned per page", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "current_page", + "description": "Current page of the cursor", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "from", + "description": "Number of the first item returned", + "type": GQL_Int, + }, + { + "name": "to", + "description": "Number of the last item returned", + "type": GQL_Int, + }, + { + "name": "last_page", + "description": "The last page (number of pages)", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "has_more_pages", + "description": "Determines if cursor has more pages after the current page", + "type": GQL_NON_NULL(GQL_Boolean), + }, + ] + +class GQL_GuildData( GQL_OBJECT ): + fields = [ + { + "name": "guild", + "description": "Obtain a specific guild either by id or by name/serverSlug/serverRegion.", + "type": "GQL_Guild", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single guild to retrieve.", + "type": GQL_Int, + }, + { + "name": "name", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + ] + }, + { + "name": "guilds", + "description": "The set of all guilds supported by the site. Can be optionally filtered to a specific server id.", + "type": "GQL_GuildPagination", + "args": [ + { + "name": "limit", + "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + { + "name": "serverID", + "description": "Optional. The ID of a specific server. If present, only guilds from that server (and any connected servers) will be fetched.", + "type": GQL_Int, + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Must be used in conjunction with serverRegion to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": GQL_String, + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific server. Must be used in conjunction with serverSlug to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": GQL_String, + }, + ] + }, + ] + +class GQL_ProgressRaceData( GQL_OBJECT ): + fields = [ + { + "name": "progressRace", + "description": "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.", + "type": GQL_JSON, + "args": [ + { + "name": "serverRegion", + "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": GQL_String, + }, + { + "name": "serverSubregion", + "description": "Optional. The short name of a subregion to filter to. Must be paired with serverRegion. Rankings for that specific subregion will be fetched.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": GQL_String, + }, + { + "name": "zoneID", + "description": "Optional. If not specified, the latest zone will be used.", + "type": GQL_Int, + }, + { + "name": "competitionID", + "description": "Optional. If not specified, the race to world first competition will be used.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. If not specified, the highest difficulty will be used.", + "type": GQL_Int, + }, + { + "name": "size", + "description": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": GQL_Int, + }, + { + "name": "guildID", + "description": "Optional. The ID of a single guild to retrieve.", + "type": GQL_Int, + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + ] + }, + { + "name": "detailedComposition", + "description": "Detailed composition data for a given guild and encounter.", + "type": GQL_JSON, + "args": [ + { + "name": "competitionID", + "description": "Optional. If not specified, the race to world first competition will be used.", + "type": GQL_Int, + }, + { + "name": "guildID", + "description": "Optional. The ID of a single guild to retrieve.", + "type": GQL_Int, + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "serverSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "serverRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "encounterID", + "description": "Optional. If not specified, the current boss that is being pulled will be used.", + "type": GQL_Int, + }, + { + "name": "difficulty", + "description": "Optional. If not specified, the highest difficulty will be used.", + "type": GQL_Int, + }, + { + "name": "size", + "description": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_RateLimitData( GQL_OBJECT ): + fields = [ + { + "name": "limitPerHour", + "description": "The total amount of points this API key can spend per hour.", + "type": GQL_NON_NULL(GQL_Int), + }, + { + "name": "pointsSpentThisHour", + "description": "The total amount of points spent during this hour.", + "type": GQL_NON_NULL(GQL_Float), + }, + { + "name": "pointsResetIn", + "description": "The number of seconds remaining until the points reset.", + "type": GQL_NON_NULL(GQL_Int), + }, + ] + +class GQL_ReportData( GQL_OBJECT ): + fields = [ + { + "name": "report", + "description": "Obtain a specific report by its code.", + "type": "GQL_Report", + "args": [ + { + "name": "code", + "description": "Required. The code of a single report to retrieve.", + "type": GQL_String, + }, + ] + }, + { + "name": "reports", + "description": "A set of reports for a specific guild, guild tag, or user.", + "type": "GQL_ReportPagination", + "args": [ + { + "name": "endTime", + "description": "Optional. A UNIX timestamp with millisecond precision representing the end time for a report range. If omitted, defaults to the current time in milliseconds.", + "type": GQL_Float, + }, + { + "name": "guildID", + "description": "Optional. The ID of a specific guild. Reports from that guild will be fetched.", + "type": GQL_Int, + }, + { + "name": "guildName", + "description": "Optional. The name of a specific guild. Must be used in conjunction with guildServerSlug and guildServerRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "guildServerSlug", + "description": "Optional. The name of a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "guildServerRegion", + "description": "Optional. The region for a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": GQL_String, + }, + { + "name": "guildTagID", + "description": "Optional. The ID of a specific guild tag. Reports from that guild tag will be fetched. This will take precedence over all other guild arguments.", + "type": GQL_Int, + }, + { + "name": "userID", + "description": "Optional. The ID of a specific user. Reports from that user's personal logs will be fetched.", + "type": GQL_Int, + }, + { + "name": "limit", + "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": GQL_Int, + }, + { + "name": "page", + "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": GQL_Int, + }, + { + "name": "startTime", + "description": "Optional. A UNIX timestamp with millisecond precision representing a start time for a report range. If omitted, defaults to 0.", + "type": GQL_Float, + }, + { + "name": "zoneID", + "description": "Optional. The ID of a specific zone to filter to. Reports with that zone as their default will be included.", + "type": GQL_Int, + }, + { + "name": "gameZoneID", + "description": "Optional. The ID of a specific game zone to filter reports to.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL_UserData( GQL_OBJECT ): + fields = [ + { + "name": "user", + "description": "Obtain a specific user by id.", + "type": "GQL_User", + "args": [ + { + "name": "id", + "description": "Required. Specify a single user ID to retrieve.", + "type": GQL_Int, + }, + ] + }, + { + "name": "currentUser", + "description": "Obtain the current user (only works with user endpoint).", + "type": "GQL_User", + }, + ] + +class GQL_WorldData( GQL_OBJECT ): + fields = [ + { + "name": "encounter", + "description": "Obtain a specific encounter by id.", + "type": "GQL_Encounter", + "args": [ + { + "name": "id", + "description": "Required. Specify a single encounter ID to retrieve.", + "type": GQL_Int, + }, + ] + }, + { + "name": "expansion", + "description": "A single expansion obtained by ID.", + "type": "GQL_Expansion", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single expansion to retrieve.", + "type": GQL_Int, + }, + ] + }, + { + "name": "expansions", + "description": "The set of all expansions supported by the site.", + "type": GQL_LIST("GQL_Expansion"), + }, + { + "name": "region", + "description": "Obtain a specific region by its ID.", + "type": "GQL_Region", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single region to retrieve.", + "type": GQL_Int, + }, + ] + }, + { + "name": "regions", + "description": "The set of all regions supported by the site.", + "type": GQL_LIST("GQL_Region"), + }, + { + "name": "server", + "description": "Obtain a specific server either by id or by slug and region.", + "type": "GQL_Server", + "args": [ + { + "name": "id", + "description": "Optional. The ID of a single server to retrieve.", + "type": GQL_Int, + }, + { + "name": "region", + "description": "Optional. The compact English abbreviation for a specific region (e.g., "US"). Use in conjunction with the server slug to retrieve a single server.", + "type": GQL_String, + }, + { + "name": "slug", + "description": "Optional. A server slug. Use in conjunction with the server region to retrieve a single server.", + "type": GQL_String, + }, + ] + }, + { + "name": "subregion", + "description": "Obtain a specific subregion by its ID.", + "type": "GQL_Subregion", + "args": [ + { + "name": "id", + "description": "Required. The ID of a single subregion to retrieve.", + "type": GQL_Int, + }, + ] + }, + { + "name": "zone", + "description": "Obtain a specific zone by its ID.", + "type": "GQL_Zone", + "args": [ + { + "name": "id", + "description": "Required. The ID of a specific zone.", + "type": GQL_Int, + }, + ] + }, + { + "name": "zones", + "description": "Obtain a set of all zones supported by the site.", + "type": GQL_LIST("GQL_Zone"), + "args": [ + { + "name": "expansion_id", + "description": "Optional. The ID of a specific expansion. If omitted, the zones from all expansions will be retrieved.", + "type": GQL_Int, + }, + ] + }, + ] + +class GQL___Schema( GQL_OBJECT ): + fields = [ + { + "name": "types", + "description": "A list of all types supported by this server.", + "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___Type"))), + }, + { + "name": "queryType", + "description": "The type that query operations will be rooted at.", + "type": GQL_NON_NULL("GQL___Type"), + }, + { + "name": "mutationType", + "description": "If this server supports mutation, the type that mutation operations will be rooted at.", + "type": "GQL___Type", + }, + { + "name": "subscriptionType", + "description": "If this server support subscription, the type that subscription operations will be rooted at.", + "type": "GQL___Type", + }, + { + "name": "directives", + "description": "A list of all directives supported by this server.", + "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___Directive"))), + }, + ] + +class GQL___Type( GQL_OBJECT ): + fields = [ + { + "name": "kind", + "description": "None", + "type": GQL_NON_NULL(GQL___TypeKind), + }, + { + "name": "name", + "description": "None", + "type": GQL_String, + }, + { + "name": "description", + "description": "None", + "type": GQL_String, + }, + { + "name": "fields", + "description": "None", + "type": GQL_LIST(GQL_NON_NULL("GQL___Field")), + "args": [ + { + "name": "includeDeprecated", + "description": "None", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "interfaces", + "description": "None", + "type": GQL_LIST(GQL_NON_NULL("GQL___Type")), + }, + { + "name": "possibleTypes", + "description": "None", + "type": GQL_LIST(GQL_NON_NULL("GQL___Type")), + }, + { + "name": "enumValues", + "description": "None", + "type": GQL_LIST(GQL_NON_NULL("GQL___EnumValue")), + "args": [ + { + "name": "includeDeprecated", + "description": "None", + "type": GQL_Boolean, + }, + ] + }, + { + "name": "inputFields", + "description": "None", + "type": GQL_LIST(GQL_NON_NULL("GQL___InputValue")), + }, + { + "name": "ofType", + "description": "None", + "type": "GQL___Type", + }, + ] + +class GQL___Field( GQL_OBJECT ): + fields = [ + { + "name": "name", + "description": "None", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "description", + "description": "None", + "type": GQL_String, + }, + { + "name": "args", + "description": "None", + "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___InputValue"))), + }, + { + "name": "type", + "description": "None", + "type": GQL_NON_NULL("GQL___Type"), + }, + { + "name": "isDeprecated", + "description": "None", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "deprecationReason", + "description": "None", + "type": GQL_String, + }, + ] + +class GQL___InputValue( GQL_OBJECT ): + fields = [ + { + "name": "name", + "description": "None", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "description", + "description": "None", + "type": GQL_String, + }, + { + "name": "type", + "description": "None", + "type": GQL_NON_NULL("GQL___Type"), + }, + { + "name": "defaultValue", + "description": "A GraphQL-formatted string representing the default value for this input value.", + "type": GQL_String, + }, + ] + +class GQL___EnumValue( GQL_OBJECT ): + fields = [ + { + "name": "name", + "description": "None", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "description", + "description": "None", + "type": GQL_String, + }, + { + "name": "isDeprecated", + "description": "None", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "deprecationReason", + "description": "None", + "type": GQL_String, + }, + ] + +class GQL___Directive( GQL_OBJECT ): + fields = [ + { + "name": "name", + "description": "None", + "type": GQL_NON_NULL(GQL_String), + }, + { + "name": "description", + "description": "None", + "type": GQL_String, + }, + { + "name": "args", + "description": "None", + "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___InputValue"))), + }, + { + "name": "isRepeatable", + "description": "None", + "type": GQL_NON_NULL(GQL_Boolean), + }, + { + "name": "locations", + "description": "None", + "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL(GQL___DirectiveLocation))), + }, + ] + +class GQL_ArchonViewModels( GQL_OBJECT ): + fields = [ + { + "name": "googleAnalytics", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "game", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "translations", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "keys", + "description": "None", + "type": GQL_LIST(GQL_String), + }, + ] + }, + { + "name": "header", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "gameSlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "headerTitle", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "footer", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "indexPage", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "gamePage", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "contactPage", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "aboutPage", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "announcementPage", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "gameSlugs", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "buildsZonePageSlugs", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "buildsZonePage", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "gameSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "rankingsSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "zoneTypeSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "difficultySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "encounterSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "affixesSlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "buildsSpecPageSlugs", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "buildsSpecPage", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "gameSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "classSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "specSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "zoneTypeSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "categorySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "difficultySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "encounterSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "affixesSlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "buildsClassesAndSpecsPage", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "gameSlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "ability", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "id", + "description": "None", + "type": GQL_Int, + }, + ] + }, + { + "name": "articleCategory", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "articleCategorySlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "articleCategories", + "description": "None", + "type": GQL_JSON, + }, + { + "name": "articleSlugs", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "articleCategorySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "siteName", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "article", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "articleSlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "articleCategorySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "siteName", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "cmsNavigation", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "currentSlug", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "pageOfArticlePreviews", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "articleCategorySlug", + "description": "None", + "type": GQL_String, + }, + { + "name": "pageNumber", + "description": "None", + "type": GQL_Int, + }, + { + "name": "siteName", + "description": "None", + "type": GQL_String, + }, + ] + }, + { + "name": "snippets", + "description": "None", + "type": GQL_JSON, + "args": [ + { + "name": "snippetSlugs", + "description": "None", + "type": GQL_LIST(GQL_String), + }, + ] + }, + { + "name": "articleIndexPage", + "description": "None", + "type": GQL_JSON, + }, + ] \ No newline at end of file diff --git a/wcl/types/scalar.py b/wcl/types/scalar.py index 2de2b3a..e944891 100644 --- a/wcl/types/scalar.py +++ b/wcl/types/scalar.py @@ -1,4 +1,4 @@ -from query import GQL_SCALAR +from ..query import GQL_SCALAR """ SCALAR TYPES From f41bbfe88b91126d7a73838970296cffb0a50892 Mon Sep 17 00:00:00 2001 From: Kate Martin <51387586+renanthera@users.noreply.github.com> Date: Thu, 28 Mar 2024 21:49:07 -0600 Subject: [PATCH 7/7] a new plan exists and is mostly implemented wooo --- main.py | 553 +- wcl/__init__.py | 5 +- wcl/__main__.py | 133 +- wcl/interface.py | 2 +- wcl/query.py | 34 - wcl/request.py | 2 - wcl/schema.json | 11780 -------------------------- wcl/types/__init__.py | 12 +- wcl/types/{enum.py => enums.py} | 4 +- wcl/types/object.py | 4227 --------- wcl/types/objects.py | 4402 ++++++++++ wcl/types/primitives.py | 67 + wcl/types/{scalar.py => scalars.py} | 19 +- 13 files changed, 4775 insertions(+), 16465 deletions(-) delete mode 100644 wcl/query.py delete mode 100644 wcl/schema.json rename wcl/types/{enum.py => enums.py} (99%) delete mode 100644 wcl/types/object.py create mode 100644 wcl/types/objects.py create mode 100644 wcl/types/primitives.py rename wcl/types/{scalar.py => scalars.py} (62%) diff --git a/main.py b/main.py index b046b49..f4f5e90 100644 --- a/main.py +++ b/main.py @@ -1,333 +1,230 @@ -from os import truncate -import analyzers import wcl +import json +from functools import reduce +from inspect import getmembers -# analyzers.ignited_essence.ignited_essence( [ -# 'xrfcz1d34vjJ2LqM', -# 'ygV4kq9RLvGQ2wm8', -# 'vr1RPbDWJ9YakM8j', -# ] ) - -# analyzers.press_the_advantage.bug_detection( [ -# 'xrfcz1d34vjJ2LqM', -# 'CXgx2FPYybAjvn1H', -# 'ny4h6wmpKVbHZq7Q', -# 'gbD8RQrZK7vj1hWF' -# ] ) - -# analyzers.t31_brew.proc( [ -# 'bkrPDQ1ZtTGRphWn', -# 'YftHvBKJzh8nxa9A', -# 'qWJXamNtPbTfZ41y', -# '7Qct4AXZg8vwrqzL', -# 'ny4h6wmpKVbHZq7Q', -# 'NLMhDBTJw9zq8j2A', -# 'gjvwPqda6KpJ7z3k', -# 'mhbxMrLVFAyDt3Pz', -# 'V2Q4mHvJ8Pg1KTX6', -# 'qFfXM34xTdNaB87V', -# 'XDk2aVCLnyBFKHPr', -# ] ) - -# analyzers.flaming_germination.flaming_germination( -# [ -# 'AVRh3LdawCzY8HKB' -# ], -# [['Lagrimas', 'Katebrew', 'Dandaniel', 'Chizgoblin'], -# ['Draxxii', 'Diosita', 'Goines', 'Ralfie'], -# ['Meowge', 'Softmograne', 'Zinglefus', 'Jeefy'], -# ['Impdh', 'Skovrogue', 'Reddevviil', 'Yusoon'], -# ['Stragnim', 'Kreemlock', 'Zenvi', 'Harreks']] -# ) - -# analyzers.flaming_germination.flaming_germination( -# [ -# 'QcW7Z9wajrVRHg8h', -# 'AQhTbnvBy79a62wW', -# 'RjfChnxgt3a8Hypz', -# 'qfvFcyw6LxYHkJ1W', -# 'BmWntKhD6b3VFAkT', -# 'WhnymKat6LrC31fV', -# 'Lk31Aa2KBnTctwWC', -# 'RDkG7VxpC1haP4y3', -# 'kBfxNpzyKDY9nF1w', -# '2qWtK4JPTbw9BH8d', -# ], -# [ -# ['Sinzhu', 'Sussyj', 'Liadryn', 'Jessndecay', 'Olvil', 'Ipsa'], -# ['Honeymoon', 'Phunt', 'Dragonexarch', 'Remslock', 'Vlces', 'Mystictouch'], -# ['Learning', 'Eyebrowz', 'Glimmerer', 'Tacofajita', 'Hunkytwunky', 'Bobblywobbly'] -# ] -# ) - -""" -currently thinking about initializing everything backwards and then i don't need evals -deepest nodes first, then move outward -or some smarter init strategy where you init everything without obj deps -then check if you have resolved any deps for new objs -repeat until objs exhausted - -this allows for incomplete initialization of gql objects, as all information -is initialized prior to instantiation of any gql objects - -still need a way to ascertain parent in the gql tree, but a path must be provided -to disambaguate requests from each other, or it would be unclear which path to follow -can use that to determine ancestry of objects, thus the correct names for objects and -use the available args -""" - -""" -1. each object uses the canonical GQL typename as its name -2. each object contains two sets of references: args and fields -2. each reference contains GQL typename, local aliased name and metadata -""" - -# class GQL_OBJECT: -# name = 'GQL_OBJECT' -# fields = {} - -# params = {} - -# def __init__( self, ancestry=None ): -# # defer evaluation until runtime so classes are defined -# self.fields = [ -# field | { -# 'type': eval( field[ 'type' ] ), -# 'args': [ -# { argk: eval( argv_t ) for argk, argv_t in arg.items() } -# for arg in field[ 'args' ] -# ] -# } -# for field in self.fields -# ] - -# if ancestry: -# self.ancestors = [ eval( f'GQL_Object_{ancestry[0]}' )() ] - -# def init( self, params ): -# def ancestor_list( obj ): -# parent = obj.parent() -# if parent.name != 'GQL_OBJECT': -# yield from ancestor_list( parent ) -# yield obj - -# self.params = params -# self.ancestors = list( ancestor_list( self ) ) -# self.ancestor_names = [ ancestor.name for ancestor in self.ancestors ] -# for ancestor in self.ancestors[:-1]: -# ancestor.init( self.params ) - -# def str( self, ancestor_names ): -# assert self.params, 'Initialization incomplete' -# args_from_parent = [] -# name_from_parent = self.name -# for field in self.parent().fields: -# if isinstance( self, field[ 'type' ] ): -# args_from_parent = field[ 'args' ] -# name_from_parent = field[ 'name' ] -# args = [ -# f'{argk}: {argv}' -# for d in args_from_parent -# for argk, argv_t in d.items() -# if ( argv := self.params.get( argk ) ) -# if isinstance( argv, argv_t ) or argv_t.is_compatible( argv ) -# ] -# fields = [ -# f'{argk[ "name" ]}' -# for argk in self.fields -# if argk[ 'name' ] in self.params.keys() and argk[ 'name' ] not in ancestor_names -# ] -# args_str = f'({", ".join(args)})' if args else '' -# fields_str = f'{", ".join(fields)}' -# return name_from_parent, args_str, fields_str - -# def __str__( self ): -# string = '' -# for ancestor in reversed( self.ancestors ): -# ancestor_name, ancestor_args_str, ancestor_fields_str = ancestor.str( self.ancestor_names ) -# fields_str = ancestor_fields_str + ( ', ' if ancestor_fields_str else '' ) + string -# fields_str = f'{{{fields_str}}}' if ancestor_fields_str or string else fields_str -# string = f'{ancestor_name}{ancestor_args_str}{fields_str}' -# return f'{{{string}}}' - -# class GQL_Object_Query( GQL_OBJECT ): -# name = 'query' -# fields = [ -# { -# 'name': 'report', -# 'type': 'GQL_Object_Report', -# 'args': [ -# { 'code': 'GQL_String' }, -# ] -# }, -# ] - -# class GQL_Object_Report( GQL_Object_Query, GQL_OBJECT ): -# name = 'report' -# fields = [ -# { -# 'name': 'code', -# 'type': 'GQL_String', -# 'args': [] -# }, -# { -# 'name': 'events', -# 'type': 'GQL_Object_Events', -# 'args': [ -# { 'startTime': 'GQL_Int' }, -# { 'endTime': 'GQL_Int' }, -# ] -# } -# ] - -# class GQL_Object_Events( GQL_Object_Report, GQL_OBJECT ): -# name = 'events' -# fields = [] - -# class GQL_T: -# compatible_list = [] -# value = None -# def __init__( self, value ): -# self.value = value -# @classmethod -# def is_compatible( cls, obj ): -# if type(obj) in cls.compatible_list: +# def type_name_match( l, r ): +# def attempt( l, r ): +# if l.lower() == r.lower(): +# return True +# if l.lower() == r[ 4: ].lower(): # return True # return False -# class GQL_String( GQL_T ): -# compatible_list = [ str ] -# def __str__( self ): -# return f'"{self.value}"' - -# class GQL_Int( GQL_T ): -# compatible_list = [ int ] -# def __str__( self ): -# return str(self.value) - - -# def query_lookup( *args ): -# current = eval( f'GQL_Object_{args[0]}()' ) -# for arg in args[1:]: -# n = lambda: None -# for field in current.fields: -# if field[ 'name' ] == arg: -# n = field[ 'type' ] -# current = n() -# return current - -# params = { -# 'code': 'asdfjkl', -# 'startTime': 100, -# 'endTime': 200, -# 'report': 'asdf', -# 'events': True -# } - -# # print( query_lookup( 'query', 'report', 'events' )( params ) ) -# # print( query().report().events() ) -# # print( query().report() ) -# q = query_lookup( 'Query', 'report', 'events' ) -# q.init( params ) -# print( q ) - -# # print( query_lookup( 'query', 'report', 'events' )() ) -# # print( query_lookup( 'query', 'report' )() ) -# # print( query_lookup( 'query' )() ) - -# import unicodedata -# from keyword import iskeyword -# import random -# import sys - -# def is_allowed_unicode_char( c, position ): -# # Other_ID_Start and Other_ID_Continue are from the following webpage with the matching category (?) name -# # https://www.unicode.org/Public/15.0.0/ucd/PropList.txt -# Other_ID_Start = { '\u1885', '\u1886', '\u2118', '\u212E', '\u309B', '\u309C' } -# Other_ID_Continue = { '\u00B7', '\u0387', '\u1369', '\u1370', '\u1371', '\u19DA' } -# # id_start and id_continue category_codes are defined from the following webpage: -# # https://docs.python.org/3/reference/lexical_analysis.html#identifiers -# id_start_category_codes = { 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' } -# id_continue_category_codes = id_start_category_codes | { 'Mn', 'Mc', 'Nd', 'Pc' } -# # id_start and id_continue singletons are defined from the following webpage: -# # https://docs.python.org/3/reference/lexical_analysis.html#identifiers -# id_start_singletons = { '_' } | Other_ID_Start -# id_continue_singletons = id_start_singletons | Other_ID_Continue - -# if unicodedata.category( c ) in id_start_category_codes or c in id_start_singletons: -# return c -# if position > 0 and ( unicodedata.category( c ) in id_continue_category_codes or c in id_continue_singletons ): -# return c - -# def generate_unicode_identifier( length = 16 ): -# # This implementation is correct, but returned strings are: -# # - Unmanageably unreadable -# # - Not reliably generated due to too small of a character set (to improve readability) -# # - Requires too much pregeneration (to avoid unreliable generation) - -# # This does not generate all possible unicode identifiers, as I did not find -# # a way to find all characters that NFKC normalize to a valid character. -# def generate_chr(attempt = 0): -# c = chr( random.randrange( sys.maxunicode + 1 ) ) -# if is_allowed_unicode_char( c, 0 ): -# return c -# return generate_chr( attempt + 1 ) - -# candidate_str = ''.join( [ -# c -# for _ in range( length ) -# if ( c := generate_chr() ) -# ] ) - -# if not iskeyword( candidate_str ): -# return candidate_str -# return generate_unicode_identifier( length = length ) - -# def generate_ascii_identifier( length = 16 ): -# # Only a small subset of valid Python 3 Identifiers, but: -# # - Highly readable -# # - Still millions of combinations -# # - More trivial to generate -# MIN_ASCII = 33 -# MAX_ASCII = 126 - -# def generate_chr( position, attempts = 0 ): -# character = chr( random.randrange( MIN_ASCII, MAX_ASCII ) ) -# if is_allowed_unicode_char( character, position ): -# return character -# return generate_chr( position, attempts + 1) - -# candidate_str = '_' + ''.join( [ -# generate_chr( pos ) -# for pos in range( length - 1 ) -# ] ) - -# if not iskeyword( candidate_str ) and candidate_str.isidentifier(): -# return candidate_str -# return generate_ascii_identifier( length = length ) - - -# # for k in range( 5 ): -# # ident = generate_ascii_identifier() -# # print(ident, len(ident)) - - - -# # PROBLEM: -# # - nested classes are gross -# # - having no nested classes with their actual names results in namespace clashes -# # SOLUTION: -# # a) -# # - queries with no parents get their actual name for their object name -# # - queries with parents get an internal name, and are added to the parent with their real name via `__subclasses__()` and `setattr(...)` -# # b) -# # - infrastructure exists for type hoisting, but it may not be useful in this situation - -# # print(C()) -# # print(C().D()) - -# # print( A() ) -# # for q in A().children: -# # print( q(), q().parent() ) -# # for u in q().children: -# # print( u(), u().parent() ) +# # print( l, r, attempt( l, r ), attempt( r, l ) ) +# return attempt( l, r ) or attempt( r, l ) + +# def find_type_in_types( t ): +# assert isinstance( t, str ), 't must be a string type token' +# candidates = [ +# candidate[1] +# for candidate in getmembers( wcl.types ) +# if type_name_match( candidate[0], t ) +# ] # yapf: disable +# assert len( candidates ) != 0, f'no type candidates found for {t}' +# assert len( candidates ) < 2, f'multiple type candidates found for {t}:\n{candidates}' +# return candidates[ 0 ] + +# def eval_type( type_array, *params ): +# if isinstance( type_array, list ): +# types = [ find_type_in_types( t ) for t in type_array ] +# if len( types ) > 1: +# return reduce( lambda prev, cur: cur( prev ), types[ -2:0 ], types[ -1 ]( *params ) ) +# return types[ 0 ]( *params ) + +# def base_type( query ): +# query_root_lower = [] +# if isinstance( query, dict ): +# query_root_lower = [ key.lower() for key in query.keys() ] +# if isinstance( query, set ): +# query_root_lower = [ key.lower() for key in query ] +# if query_root_lower: +# # assert len( query_root_lower ) == 1, 'multiple root keys found in query' +# return { +# find_type_in_types( t ) +# for t in query_root_lower +# } # yapf: disable +# return None + +def match_name( l, r ): + def attempt( l, r ): + if l.lower() == r.lower(): + return True + if l.lower() == r[ 4: ].lower(): + return True + return False + + return attempt( l, r ) or attempt( r, l ) + +def find_type_from_wcl_types( token ): + # print(f'TFWT: {token} -> ',end='') + if not isinstance( token, str ): + # print(False) + return False + candidates = [ + candidate[1] + for candidate in getmembers( wcl.types ) + if match_name( candidate[0], token ) + ] + if len( candidates ) == 1: + # print(candidates[0]) + return candidates[ 0 ] + # print(False) + return False + +def find_type_from_fields( token, parent ): + # print(f'TFF: {token} {type(token)} -> ',end='') + def type_array( token_array ): + return [ + find_type_from_wcl_types( token ) + for token in token_array + ] + if not isinstance( token, str ): + # print(False) + return False + if not isinstance( parent(), wcl.types.GQL_OBJECT ): + # print(type(parent)) + return False + # print(parent.fields,end='') + fields = parent.fields + candidates = [ + type_array( field[ 'type' ] ) + for field in fields + if field[ 'name' ].lower() == token.lower() + ] + # print('CANDIDATES:', candidates) + if len( candidates ) == 1: + return candidates[0] + + return find_type_from_wcl_types( token ) + +def eval_type_array( type_array, params ): + def reducer( previous, current ): + next_obj = current() + next_obj.update( previous ) + return next_obj + + if not isinstance( type_array, list ): + return None + return reduce( reducer, type_array[ -1: 0 ], params ) + +class Query: + def __init__( self, query, params ): + self.query = query + self.params = params + + self.query_tree = self.create_tree() + + def create_tree( self, query=None, parent=None ): + # print(f'CT: {query} {parent}') + if query is None: + query = self.query + if isinstance( query, set ): + return { + key: k + for key in query + if ( k := find_type_from_wcl_types( key ) ) or ( k := find_type_from_fields( key, parent ) ) + } + + if isinstance( query, dict ): + return { + k: v + for key, value in query.items() + if ( k := find_type_from_wcl_types( key ) ) or ( k := find_type_from_fields( key, parent ) ) + if ( v := find_type_from_wcl_types( value ) ) or ( v := find_type_from_fields( value, k ) ) or ( v := self.create_tree( value, k ) ) + } + + """ + the root node(s) of queries must contain a gql_ token + the child node(s) of queries may contain either gql_ tokens or reference + aliased names found in fields + + args are populated from params dict and arg and param tokens must match + + objects are valid if: + - all required args are found in params <- this is enforced via GQL_NON_NULL + - object is found in wcl.types <- this is enforced by find_type_in_types + """ + +q = """ +alpha: query { + one: rateLimitData(arg1: 1, arg2: 2) { + limitperhour pointsspentthishour pointsresetin + } +} +beta: query { + two: rateLimitData(arg1: 3, arg2: 4) { + limitperhour pointsspentthishour pointsresetin + } +} +gamma: query { + three: rateLimitData(arg1: 5, arg2: 6) { + limitperhour pointsspentthishour pointsresetin + } +} +""" +import re, regex +def process_query( query ): + """ + alias optional + token_name required + args optional but match expected type via introspection + fields are of the same form as this object + multiple objects may exist on the same level + alias?: token_name( arg_k: arg_v... ){ ...fields } + """ + def process_token_group( query ): + def any_in( l, r ): + r = r[ 1:-1 ] + return any( [ + v in r + for v in l + ] ) + def find_tokens_in_token_group( token_group ): + count = 0 + labels = [ 0 ] + [ + index + 1 + for index, c in enumerate( token_group ) + if c == '{' and ( ( count := count + 1 ) or True ) or True + if c == '}' and ( ( count := count - 1 ) or True ) or True + if count == 0 and c in '{}' + ] + return [ + token_group[ i:j ] + for i, j in zip( labels, labels[ 1: ]+[ None ] ) + ][ :-1 ] + token_group = regex.search( '{((?>[^{}]+|(?R))*)}', query ) + token_group = token_group.group( 1 ) if token_group else '' + objects = [] + for token in find_tokens_in_token_group( token_group ): + prefix = re.search( r'^[^{}\(\)]+', token ) + prefix = prefix.group( 0 ) if prefix else '' + args = re.search( r'\(([^\)]+)\)', token ) + args = args.group( 1 ) if args else '' + fields = regex.search( '({(?>[^{}]+|(?R))*})', token ) + fields = fields.group( 1 ) if fields else '' + objects.append( { + # 'prefix': prefix, + 'alias': prefix.split( ':' )[ 0 ] if ':' in prefix else '', + 'name': prefix.split( ':' )[ 1 ] if ':' in prefix else prefix, + 'args': { + arg_k: arg_v + for arg in args.split( ', ' ) + if ( arg_split := arg.split( ':' ) ) and len( arg_split ) > 1 + if ( arg_k := arg_split[ 0 ] ) and ( arg_v := arg_split[ 1 ] ) + }, + 'fields': process_token_group( fields ) if any_in( '{}', fields ) else fields[ 1:-1 ].split( ' ' ) + } ) + return objects + def token_to_object( token ): + pass + print(query) + query = re.sub( r'\s+', ' ', query ) + query = re.sub( r': ', ':', query ) + query = re.sub( r'\s*{\s*', '{', query ) + query = re.sub( r'\s*}\s*', '}', query ) + query = query.strip() + if query[0] != '{': + query = '{' + query + '}' + print(json.dumps(process_token_group(query), indent=2)) +process_query(q) diff --git a/wcl/__init__.py b/wcl/__init__.py index 75e74d0..a311a5a 100644 --- a/wcl/__init__.py +++ b/wcl/__init__.py @@ -1,4 +1 @@ -# from .interface import * -# from .query import * - -from . import interface, query, request +from . import interface, request, types diff --git a/wcl/__main__.py b/wcl/__main__.py index b1e1b77..4f85661 100644 --- a/wcl/__main__.py +++ b/wcl/__main__.py @@ -1,31 +1,4 @@ -import json from .request import Request -from .types import * - -""" -1. each object uses the canonical GQL typename as its name -2. each object contains two sets of references: args and fields -2. each reference contains GQL typename, local aliased name and metadata -""" -""" -BASE KINDS: -SCALAR, -OBJECT, -ENUM - -META KINDS: -NON_NULL, -LIST -""" - -""" -TODO: -sort the objects -make sure i can use the type objects to make the thing :tm: -create a thing that finds the correct query objects -stringify -""" - class SchemaIntrospection: schema_location = 'wcl/introspection_query.json' @@ -43,28 +16,39 @@ def __str__( self ): schema_query = SchemaIntrospection() schema_request_data = Request( schema_query ).data +# Headers of generated wcl type files: objects = { 'ENUM': [ -"""from ..query import GQL_ENUM + """from .primitives import GQL_ENUM \"\"\" ENUM TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. +THIS FILE IS GENERATED BY `wcl/__main__.py`. \"\"\"""" ], 'OBJECT': [ -"""from ..query import * -from .enum import * -from .scalar import * + """from .primitives import * +from .enums import * +from .scalars import * \"\"\" OBJECT TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. +THIS FILE IS GENERATED BY `wcl/__main__.py`. \"\"\"""" - ] + ], + 'SCALAR': [] } tab = ' ' + +def resolve_type( t ): + kind = t[ 'kind' ] + if kind in [ 'OBJECT', 'SCALAR', 'ENUM' ]: + name = t[ 'name' ] + return [ f'"GQL_{name}"' ] + else: + return [ f'"GQL_{kind}"', *resolve_type( t[ 'ofType' ] ) ] + def handle_enum( entry ): assert entry[ 'kind' ] == 'ENUM' longest_str = max( [ len( enum_value[ 'name' ] ) for enum_value in entry[ 'enumValues' ] ] ) @@ -83,31 +67,22 @@ def handle_enum( entry ): def handle_object( entry ): def format_type( t ): - type_arr = resolve_type( t ) - return '('.join( type_arr ) + ')' * ( len( type_arr ) - 1 ) + "," - - def resolve_type( t ): - kind = t[ 'kind' ] - if kind in [ 'OBJECT', 'SCALAR', 'ENUM' ]: - name = t[ 'name' ] - if kind != 'OBJECT': - return [ f'GQL_{name}' ] - else: - return [ f'"GQL_{name}"' ] - else: - return [ f'GQL_{kind}' ] + resolve_type( t[ 'ofType' ] ) + return f'[{",".join(resolve_type(t))}]' def format_field( field ): def base_filter( field ): - key_filter = [ - 'name', - 'description' - ] + key_filter = [ 'name', 'description' ] + name = field[ 'name' ] + description = field[ 'description' ].replace( '"', "'" ) if field[ 'description' ] is not None else '' + return [ + f'{tab}"name": "{name}",', + f'{tab}"descrption": "{description}",' + ] # yapf: disable return [ f'{tab}"{key}": "{value}",' for key, value in field.items() if key in key_filter - ] + ] # yapf: disable def format_arg( arg ): return [ @@ -116,9 +91,9 @@ def format_arg( arg ): f'{line}' for line in base_filter( arg ) ], - f'{tab}"type": {format_type(arg["type"])}', + f'{tab}"type": {format_type(arg["type"])},', '},' - ] + ] # yapf: disable def format_args( args ): if args: @@ -131,23 +106,29 @@ def format_args( args ): for line in arg_lines ], ']' - ] + ] # yapf: disable return [] return [ '{', *base_filter( field ), - f'{tab}"type": {format_type(field["type"])}', + f'{tab}"type": {format_type(field["type"])},', *[ f'{tab}{line}' for line in format_args( field[ 'args' ] ) ], '},' - ] + ] # yapf: disable assert entry[ 'kind' ] == 'OBJECT' + descr = [ + f'{tab}"""', + f'{tab}{entry["description"]}', + f'{tab}"""' + ] if entry[ 'description' ] else [] lines = [ f'class GQL_{entry["name"]}( GQL_OBJECT ):', + *descr, f'{tab}fields = [', *[ f'{tab}{tab}{line}' @@ -156,28 +137,40 @@ def format_args( args ): for line in formatted_field ], f'{tab}]' - ] - print(json.dumps(entry, indent=2)) - print(json.dumps(lines, indent=2)) + ] # yapf: disable return '\n'.join( lines ) for k in schema_request_data[ 'types' ]: kind = k[ 'kind' ] if kind in objects.keys(): - current = objects[ kind ] + entry = { + 'name': k[ 'name' ], + 'data': k, + 'value': None + } match kind: case 'ENUM': - current.append( handle_enum( k ) ) + entry.update( { + 'string': handle_enum( k ) + } ) case 'OBJECT': - current.append( handle_object( k ) ) + entry.update( { + 'string': handle_object( k ) + } ) + case 'SCALAR': + pass case _: pass + objects[ kind ].append( entry ) # pyright: ignore - objects.update( { - kind: current - } ) -for kind, values in objects.items(): - with open( f'wcl/types/{kind.lower()}.py', 'w' ) as handle: - handle.write( '\n\n'.join( values ) ) +def join_values( values ): + for value in values: + if isinstance( value, dict ): + yield ''.join( value[ 'string' ] ) + else: + yield ''.join( value ) -scalar.GQL_Boolean( True ) +for kind, values in objects.items(): + if kind in [ 'OBJECT', 'ENUM' ]: + with open( f'wcl/types/{kind.lower()}s.py', 'w' ) as handle: + handle.write( '\n\n'.join( join_values( values ) ) ) diff --git a/wcl/interface.py b/wcl/interface.py index 693de80..810393d 100644 --- a/wcl/interface.py +++ b/wcl/interface.py @@ -1,7 +1,7 @@ import json from copy import deepcopy -from . import query, request +from . import request def getFights( params ): return request.Request( query.Fights( params ) ).data diff --git a/wcl/query.py b/wcl/query.py deleted file mode 100644 index b05af00..0000000 --- a/wcl/query.py +++ /dev/null @@ -1,34 +0,0 @@ -class GQL_KIND: - def __init__( self, data ): - self.data = data - assert self.is_valid() - - def __str__( self ): - return str( self.data ) - - def is_valid( self ): - return False - -class GQL_SCALAR( GQL_KIND ): - def is_valid( self ): - return True - -class GQL_ENUM( GQL_KIND ): - enum_values = [] - - def is_valid( self ): - return self.data in self.enum_values - -class GQL_OBJECT( GQL_KIND ): - pass - -class GQL_NON_NULL( GQL_KIND ): - def is_valid( self ): - return isinstance( self.data, GQL_KIND ) and self.data.is_valid() - -class GQL_LIST( GQL_KIND ): - def __str__( self ): - return '[' + ', '.join( [ str( datum ) for datum in self.data ] ) + ']' - - def is_valid( self ): - return isinstance( self.data, list ) and all( [ hasattr( datum, 'is_valid' ) and datum.is_valid() for datum in self.data ] ) # yapf: disable diff --git a/wcl/request.py b/wcl/request.py index ce7caeb..d62b767 100644 --- a/wcl/request.py +++ b/wcl/request.py @@ -92,5 +92,3 @@ def drill_down( data, keys ): body[ 'data' ] += self.get_request().get( 'data' ) return body - - # TODO: better object resolution diff --git a/wcl/schema.json b/wcl/schema.json deleted file mode 100644 index 7a48c7b..0000000 --- a/wcl/schema.json +++ /dev/null @@ -1,11780 +0,0 @@ -{ - "data": { - "__schema": { - "queryType": { - "name": "Query" - }, - "mutationType": null, - "subscriptionType": null, - "types": [ - { - "kind": "OBJECT", - "name": "Query", - "description": null, - "fields": [ - { - "name": "characterData", - "description": "Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "CharacterData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameData", - "description": "Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..", - "args": [], - "type": { - "kind": "OBJECT", - "name": "GameData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guildData", - "description": "Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "GuildData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "progressRaceData", - "description": "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.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "ProgressRaceData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rateLimitData", - "description": "Obtain the rate limit data object to see how many points have been spent by this key.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "RateLimitData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "reportData", - "description": "Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "ReportData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "userData", - "description": "Obtain the user object that allows the retrieval of the authorized user's id and username.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "UserData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "worldData", - "description": "Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon\/raid zones, and encounters.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "WorldData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "CharacterData", - "description": "The CharacterData object enables the retrieval of single characters or filtered collections of characters.", - "fields": [ - { - "name": "character", - "description": "Obtain a specific character either by id or by name\/server_slug\/server_region.", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single character to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "name", - "description": "Optional. The name of a specific character. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a character.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverSlug", - "description": "Optional. The slug of a specific server. Must be used in conjunction with name and serverRegion to uniquely identify a character.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific character. Must be used in conjunction with name and serverRegion to uniquely identify a character.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Character", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "characters", - "description": "A collection of characters for a specific guild.", - "args": [ - { - "name": "guildID", - "description": "Required. The ID of a specific guild. Characters from that guild will be fetched.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "CharacterPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "Int", - "description": "The `Int` scalar type represents non-fractional signed whole numeric\nvalues. Int can represent values between -(2^31) and 2^31 - 1. ", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "String", - "description": "The `String` scalar type represents textual data, represented as UTF-8\ncharacter sequences. The String type is most often used by GraphQL to\nrepresent free-form human-readable text.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Character", - "description": "A player character. Characters can earn individual rankings and appear in reports.", - "fields": [ - { - "name": "canonicalID", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "claimed", - "description": "Whether this character is claimed by the current user. Only accessible if accessed via the user API with the \"view-user-profile\" scope.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "classID", - "description": "The class id of the character.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "encounterRankings", - "description": "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.", - "args": [ - { - "name": "byBracket", - "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": { - "kind": "ENUM", - "name": "RankingCompareType", - "ofType": null - }, - "defaultValue": "Rankings" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Required. The specific encounter whose rankings should be fetched.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "includeCombatantInfo", - "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "includePrivateLogs", - "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", - "type": { - "kind": "ENUM", - "name": "CharacterRankingMetricType", - "ofType": null - }, - "defaultValue": "default" - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "role", - "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", - "type": { - "kind": "ENUM", - "name": "RoleType", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": { - "kind": "ENUM", - "name": "RankingTimeframeType", - "ofType": null - }, - "defaultValue": "Historical" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "faction", - "description": "The faction of the character.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameFaction", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameData", - "description": "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.", - "args": [ - { - "name": "specID", - "description": "Optional. A specific spec ID to retrieve information for. If omitted, the last observed spec on Armory (WoW) or Lodestone (FF) will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "forceUpdate", - "description": "Optional. Whether or not to force the updating of the character before returning the game data.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guildRank", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guilds", - "description": "All guilds that the character belongs to.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "hidden", - "description": "Whether or not the character has all its rankings hidden.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The ID of the character.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "level", - "description": "The level of the character.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the character.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "recentReports", - "description": "Recent reports for the character.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of recent reports to retrieve. If omitted, defaults to 10. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "10" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "ReportPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "server", - "description": "The server that the character belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Server", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zoneRankings", - "description": "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.", - "args": [ - { - "name": "byBracket", - "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": { - "kind": "ENUM", - "name": "RankingCompareType", - "ofType": null - }, - "defaultValue": "Rankings" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "includePrivateLogs", - "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", - "type": { - "kind": "ENUM", - "name": "CharacterRankingMetricType", - "ofType": null - }, - "defaultValue": "default" - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "role", - "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", - "type": { - "kind": "ENUM", - "name": "RoleType", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": { - "kind": "ENUM", - "name": "RankingTimeframeType", - "ofType": null - }, - "defaultValue": "Historical" - }, - { - "name": "zoneID", - "description": "Optional. If not specified, the latest unfrozen zone will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "Boolean", - "description": "The `Boolean` scalar type represents `true` or `false`.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "RankingCompareType", - "description": "Whether or not rankings are compared against best scores for the entire tier or against all parses in a two week window.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Rankings", - "description": "Compare against rankings.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Parses", - "description": "Compare against all parses in a two week window.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "CharacterRankingMetricType", - "description": "All the possible metrics.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "bosscdps", - "description": "Boss cDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bossdps", - "description": "Boss damage per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bossndps", - "description": "Boss nDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bossrdps", - "description": "Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "default", - "description": "Choose an appropriate default depending on the other selected parameters.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "dps", - "description": "Damage per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "hps", - "description": "Healing per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "krsi", - "description": "Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "playerscore", - "description": "Score. Used by WoW Mythic dungeons and by ESO trials.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "playerspeed", - "description": "Speed. Not supported by every zone.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "cdps", - "description": "cDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ndps", - "description": "nDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rdps", - "description": "rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankhps", - "description": "Healing done per second to tanks.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "wdps", - "description": "Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombineddps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedbossdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedcdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedbosscdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedndps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedbossndps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedrdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "healercombinedbossrdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of healers in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombineddps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedbossdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedcdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedbosscdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedndps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedbossndps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedrdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankcombinedbossrdps", - "description": "Unique to FFXIV. Represents the combined ranking for a pair of tanks in eight player content.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "RoleType", - "description": "Used to specify a tank, healer or DPS role.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Any", - "description": "Fetch any role..", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DPS", - "description": "Fetch the DPS role only.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Healer", - "description": "Fetch the healer role only.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Tank", - "description": "Fetch the tanking role only.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "RankingTimeframeType", - "description": "Whether or not rankings are today or historical.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Today", - "description": "Compare against today's rankings.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Historical", - "description": "Compare against historical rankings.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "JSON", - "description": "", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameFaction", - "description": "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.", - "fields": [ - { - "name": "id", - "description": "An integer representing the faction id.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the faction.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Guild", - "description": "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.", - "fields": [ - { - "name": "attendance", - "description": null, - "args": [ - { - "name": "guildTagID", - "description": "Optional. Whether or not to filter the attendance to a specific guild tag.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "limit", - "description": "Optional. The number of reports to retrieve per page. If omitted, defaults to 16. The maximum allowed value is 25, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "16" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "zoneID", - "description": "Optional. Whether or not to filter the attendance table to a specific zone.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GuildAttendancePagination", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "competitionMode", - "description": "Whether or not the guild has competition mode enabled.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": "The description for the guild that is displayed with the guild name on the site.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "faction", - "description": "The faction of the guild.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameFaction", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The ID of the guild.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the guild.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "server", - "description": "The server that the guild belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Server", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "stealthMode", - "description": "Whether or not the guild has stealth mode enabled.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tags", - "description": "The tags used to label reports. In the site UI, these are called raid teams.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GuildTag", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "members", - "description": "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.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "CharacterPagination", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "currentUserRank", - "description": "The current user's rank within the guild. Only accessible via user authentication with the \"view-user-profile\" scope.", - "args": [], - "type": { - "kind": "ENUM", - "name": "GuildRank", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zoneRanking", - "description": "The guild's ranking for a zone. If `zoneId` is unset or null, uses the latest zone.", - "args": [ - { - "name": "zoneId", - "description": null, - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GuildZoneRankings", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildAttendancePagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GuildAttendance", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildAttendance", - "description": "Attendance for a specific report within a guild.", - "fields": [ - { - "name": "code", - "description": "The code of the report for the raid night.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "players", - "description": "The players that attended that raid night.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "PlayerAttendance", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "startTime", - "description": "The start time of the raid night.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zone", - "description": "The principal zone of the raid night.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "PlayerAttendance", - "description": "Attendance for a specific player on a specific raid night.", - "fields": [ - { - "name": "name", - "description": "The name of the player.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": "The class of the player.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "presence", - "description": "Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "Float", - "description": "The `Float` scalar type represents signed double-precision fractional\nvalues as specified by\n[IEEE 754](http:\/\/en.wikipedia.org\/wiki\/IEEE_floating_point). ", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Zone", - "description": "A single zone from an expansion that represents a raid, dungeon, arena, etc.", - "fields": [ - { - "name": "id", - "description": "The ID of the zone.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "brackets", - "description": "The bracket information for this zone. This field will be null if the zone does not support brackets.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "Bracket", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "difficulties", - "description": "A list of all the difficulties supported for this zone.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Difficulty", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "encounters", - "description": "The encounters found within this zone.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Encounter", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "expansion", - "description": "The expansion that this zone belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Expansion", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "frozen", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the zone.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "partitions", - "description": "A list of all the partitions supported for this zone.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Partition", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Bracket", - "description": "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.", - "fields": [ - { - "name": "min", - "description": "An integer representing the minimum value used by bracket number 1, etc.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "max", - "description": "An integer representing the value used by bracket N when there are a total of N brackets, etc.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bucket", - "description": "A float representing the value to increment when moving from bracket 1 to bracket N, etc.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": "The localized name of the bracket type.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Difficulty", - "description": "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.", - "fields": [ - { - "name": "id", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name for the difficulty level.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "sizes", - "description": "A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Encounter", - "description": "A single encounter for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the encounter.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the encounter.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "characterRankings", - "description": "Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", - "args": [ - { - "name": "bracket", - "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "filter", - "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "page", - "description": "Optional. Which page of rankings to fetch. By default the first page is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "leaderboard", - "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", - "type": { - "kind": "ENUM", - "name": "LeaderboardRank", - "ofType": null - }, - "defaultValue": "Any" - }, - { - "name": "hardModeLevel", - "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", - "type": { - "kind": "ENUM", - "name": "HardModeLevelRankFilter", - "ofType": null - }, - "defaultValue": "Any" - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific player metric like dps or hps. If omitted, an appropriate default player metric for the zone will be chosen.", - "type": { - "kind": "ENUM", - "name": "CharacterRankingMetricType", - "ofType": null - }, - "defaultValue": "default" - }, - { - "name": "includeCombatantInfo", - "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. If omitted, data for all classes will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "externalBuffs", - "description": "Optional. Controls whether to include ranks with\/without external buffs. Most games and zones do not support this filter and will quietly ignore it.", - "type": { - "kind": "ENUM", - "name": "ExternalBuffRankFilter", - "ofType": null - }, - "defaultValue": "Any" - }, - { - "name": "covenantID", - "description": "Optional. The covenant ID to filter to if viewing Shadowlands rankings.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "soulbindID", - "description": "Optional. The soulbind ID to filter to if viewing Shadowlands rankings.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "fightRankings", - "description": "Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", - "args": [ - { - "name": "bracket", - "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "filter", - "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "page", - "description": "Optional. Which page of rankings to fetch. By default the first page is used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "leaderboard", - "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", - "type": { - "kind": "ENUM", - "name": "LeaderboardRank", - "ofType": null - }, - "defaultValue": "Any" - }, - { - "name": "hardModeLevel", - "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", - "type": { - "kind": "ENUM", - "name": "HardModeLevelRankFilter", - "ofType": null - }, - "defaultValue": "Any" - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific fight metric like speed or execution. If omitted, an appropriate default fight metric for the zone will be chosen.", - "type": { - "kind": "ENUM", - "name": "FightRankingMetricType", - "ofType": null - }, - "defaultValue": "default" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zone", - "description": "The zone that this encounter is found in.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "journalID", - "description": "The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "LeaderboardRank", - "description": "Source of the rank. Most ranks only support log ranks, but some games (ESO) and content types (Retail WoW M+) support leaderboard ranks with no backing log.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Any", - "description": "All ranks are included.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "LogsOnly", - "description": "Only include ranks with a backing log.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "HardModeLevelRankFilter", - "description": "Hard mode level filter. Used for WoW Classic Hard Modes. For ESO hard modes, use `difficulty`. Hard mode levels range from 0-4, with 0 being normal mode and 4 being the highest hard mode.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Any", - "description": "Any hard mode level (including normal mode).", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Highest", - "description": "The highest hard mode level. Convenience alias for hard mode level 4.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "NormalMode", - "description": "The normal (non-hard) mode level. Convenience alias for hard mode level 0.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Level0", - "description": "Hard mode level 0.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Level1", - "description": "Hard mode level 1.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Level2", - "description": "Hard mode level 2.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Level3", - "description": "Hard mode level 3.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Level4", - "description": "Hard mode level 4.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "ExternalBuffRankFilter", - "description": "Whether to include ranks with major external buffs. Not all metrics, zones and games support this. It will be ignored if unsupported.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Any", - "description": "Include all ranks, regardless of external buffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Require", - "description": "Only include ranks that DO CONTAIN external buffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Exclude", - "description": "Only include ranks that DO NOT CONTAIN external buffs.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "FightRankingMetricType", - "description": "All the possible metrics.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "default", - "description": "Choose an appropriate default depending on the other selected parameters.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "execution", - "description": "A metric that rewards minimizing deaths and damage taken.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "feats", - "description": "Feats of strength in WoW or Challenges in FF.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "score", - "description": "For Mythic+ dungeons in WoW, represents the team's score. Used for ESO trials and dungeons also.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "speed", - "description": "Speed metric, based off the duration of the fight.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "progress", - "description": "Progress metric, based off when the fight was defeated.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Expansion", - "description": "A single expansion for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the expansion.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the expansion.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zones", - "description": "The zones (e.g., raids and dungeons) supported for this expansion.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Partition", - "description": "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.", - "fields": [ - { - "name": "id", - "description": "An integer representing a specific partition within a zone.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name for partition.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "compactName", - "description": "The compact localized name for the partition. Typically an abbreviation to conserve space.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "default", - "description": "Whether or not the partition is the current default when viewing rankings or statistics for the zone.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Server", - "description": "A single server. Servers correspond to actual game servers that characters and guilds reside on.", - "fields": [ - { - "name": "id", - "description": "The ID of the server.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the server in the locale of the subregion that the server belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "normalizedName", - "description": "The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "slug", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "region", - "description": "The region that this server belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Region", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "subregion", - "description": "The subregion that this server belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Subregion", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guilds", - "description": "The guilds found on this server (and any servers connected to this one.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of guilds to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "10" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GuildPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "characters", - "description": "The characters found on this server (and any servers connected to this one.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "10" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "CharacterPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Region", - "description": "A single region for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the region.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "compactName", - "description": "The localized compact name of the region, e.g., US for United States.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the region.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "slug", - "description": "The slug for the region, usable when looking up characters and guilds by server.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "subregions", - "description": "The subregions found within this region.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Subregion", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "servers", - "description": "The servers found within this region.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "ServerPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Subregion", - "description": "A single subregion. Subregions are used to divide a region into sub-categories, such as French or German subregions of a Europe region.", - "fields": [ - { - "name": "id", - "description": "The ID of the subregion.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the subregion.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "region", - "description": "The region that this subregion is found in.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Region", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "servers", - "description": "The servers found within this region.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "ServerPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ServerPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Server", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "CharacterPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Character", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildTag", - "description": "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.", - "fields": [ - { - "name": "id", - "description": "The ID of the tag.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guild", - "description": "The guild that the tag belongs to.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the tag.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "GuildRank", - "description": "Rank within a guild or team on the website. This is separate from in-game ranks and does NOT correspond to the rank of the user or character in-game.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "NonMember", - "description": "The user is not a member of this guild or team.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Applicant", - "description": null, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Recruit", - "description": null, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Member", - "description": null, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Officer", - "description": null, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "GuildMaster", - "description": null, - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildZoneRankings", - "description": "A guild's rankings within a zone.", - "fields": [ - { - "name": "progress", - "description": "The progress ranks for the guild. Always uses the highest difficulty.", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "WorldRegionServerRankPositions", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "speed", - "description": "The all-star based speed rank for the guild.", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "difficulty", - "description": "Raid difficulty.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "WorldRegionServerRankPositions", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "completeRaidSpeed", - "description": "The complete raid speed ranks for the guild. Most non-Classic WoW zones do not support complete raid ranks.", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "difficulty", - "description": "Raid difficulty.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "WorldRegionServerRankPositions", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "WorldRegionServerRankPositions", - "description": "A collection containing some combination of world, region, and server ranks.", - "fields": [ - { - "name": "worldRank", - "description": null, - "args": [], - "type": { - "kind": "OBJECT", - "name": "Rank", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "regionRank", - "description": null, - "args": [], - "type": { - "kind": "OBJECT", - "name": "Rank", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "serverRank", - "description": null, - "args": [], - "type": { - "kind": "OBJECT", - "name": "Rank", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Rank", - "description": null, - "fields": [ - { - "name": "number", - "description": "The ordinal rank (usually written \"Rank N\"). Rank 1 = highest.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "percentile", - "description": "The percentile of the rank as an integer in [0, 100]. Always null for guild ranks.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "color", - "description": "The color class used by the site for this rank.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Report", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "Report", - "description": "A single report uploaded by a player to a guild or personal logs.", - "fields": [ - { - "name": "code", - "description": "The report code, a unique value used to identify the report.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "endTime", - "description": "The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "events", - "description": "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.", - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": { - "kind": "ENUM", - "name": "EventDataType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": { - "kind": "ENUM", - "name": "HostilityType", - "ofType": null - }, - "defaultValue": "Friendlies" - }, - { - "name": "includeResources", - "description": "Optional. Whether or not to include detailed unit resources for actors. Adds substantially to bandwidth, so defaults to off.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": { - "kind": "ENUM", - "name": "KillType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "limit", - "description": "Optional. How many events to retrieve. Allowed value ranges are 100-10000. The default value is 300.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "300" - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if is a priority, and you do not care about the names.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - }, - { - "name": "useAbilityIDs", - "description": "Optional. Whether or not to include detailed ability information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - }, - { - "name": "useActorIDs", - "description": "Optional. Whether or not to include detailed actor information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "OBJECT", - "name": "ReportEventPaginator", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "exportedSegments", - "description": "The number of exported segments in the report. This is how many segments have been processed for rankings.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "fights", - "description": "A set of fights with details about participating players.", - "args": [ - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": { - "kind": "ENUM", - "name": "KillType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportFight", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "graph", - "description": "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.", - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": { - "kind": "ENUM", - "name": "GraphDataType", - "ofType": null - }, - "defaultValue": "Summary" - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": { - "kind": "ENUM", - "name": "HostilityType", - "ofType": null - }, - "defaultValue": "Friendlies" - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": { - "kind": "ENUM", - "name": "KillType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "viewBy", - "description": "Optional. Whether to view by source, by target or by ability.", - "type": { - "kind": "ENUM", - "name": "ViewType", - "ofType": null - }, - "defaultValue": "Default" - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guild", - "description": "The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guildTag", - "description": "The guild tag that the report belongs to. If this is null, then the report was not tagged.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "GuildTag", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "owner", - "description": "The user that uploaded the report.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "User", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "masterData", - "description": "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.", - "args": [ - { - "name": "translate", - "description": "Optional. Whether or not the actors and abilities in the master data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names of abilities and actors.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - } - ], - "type": { - "kind": "OBJECT", - "name": "ReportMasterData", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "playerDetails", - "description": "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.", - "args": [ - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": { - "kind": "ENUM", - "name": "KillType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rankedCharacters", - "description": "A list of all characters that ranked on kills in the report.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Character", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rankings", - "description": "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.", - "args": [ - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": { - "kind": "ENUM", - "name": "RankingCompareType", - "ofType": null - }, - "defaultValue": "Rankings" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "playerMetric", - "description": "Optional. You can filter to a specific player metric like dps or hps.", - "type": { - "kind": "ENUM", - "name": "ReportRankingMetricType", - "ofType": null - }, - "defaultValue": "default" - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": { - "kind": "ENUM", - "name": "RankingTimeframeType", - "ofType": null - }, - "defaultValue": "Today" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "region", - "description": "The region of the report.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "Region", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "revision", - "description": "The revision of the report. This number is increased when reports get re-exported.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "segments", - "description": "The number of uploaded segments in the report.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "startTime", - "description": "The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "table", - "description": "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.", - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": { - "kind": "ENUM", - "name": "TableDataType", - "ofType": null - }, - "defaultValue": "Summary" - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": "[]" - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": { - "kind": "ENUM", - "name": "HostilityType", - "ofType": null - }, - "defaultValue": "Friendlies" - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": { - "kind": "ENUM", - "name": "KillType", - "ofType": null - }, - "defaultValue": "All" - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"Any\"" - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "true" - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "viewBy", - "description": "Optional. Whether to view by source, by target or by ability.", - "type": { - "kind": "ENUM", - "name": "ViewType", - "ofType": null - }, - "defaultValue": "Default" - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "title", - "description": "A title for the report.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "visibility", - "description": "The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zone", - "description": "The principal zone that the report contains fights for. Null if no supported zone exists.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "archiveStatus", - "description": "Whether this report has been archived. Events, tables, and graphs for archived reports are inaccessible unless the retrieving user has a subscription including archive access.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "ReportArchiveStatus", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "phases", - "description": "Phase information for all boss encounters observed in this report. This requires loading fight data, but does not double-charge API points if you load fights and phases.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "EncounterPhases", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "EventDataType", - "description": "The type of events or tables to examine.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "All", - "description": "All Events", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Buffs", - "description": "Buffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Casts", - "description": "Casts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "CombatantInfo", - "description": "Combatant info events (includes gear).", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageDone", - "description": "Damage done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageTaken", - "description": "Damage taken.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Deaths", - "description": "Deaths.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Debuffs", - "description": "Debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Dispels", - "description": "Dispels.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Healing", - "description": "Healing done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Interrupts", - "description": "Interrupts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Resources", - "description": "Resources.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Summons", - "description": "Summons", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Threat", - "description": "Threat.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "HostilityType", - "description": "Whether or not to fetch information for friendlies or enemies.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Friendlies", - "description": "Fetch information for friendlies.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Enemies", - "description": "Fetch information for enemies.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "KillType", - "description": "A filter for kills vs wipes and encounters vs trash.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "All", - "description": "Include trash and encounters.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Encounters", - "description": "Only include encounters (kills and wipes).", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Kills", - "description": "Only include encounters that end in a kill.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Trash", - "description": "Only include trash.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Wipes", - "description": "Only include encounters that end in a wipe.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportEventPaginator", - "description": "The ReportEventPaginator represents a paginated list of report events.", - "fields": [ - { - "name": "data", - "description": "The list of events obtained.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "nextPageTimestamp", - "description": "A timestamp to pass in as the start time when fetching the next page of data.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportFight", - "description": "The ReportFight represents a single fight that occurs in the report.", - "fields": [ - { - "name": "averageItemLevel", - "description": "The average item level of the players in the fight.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bossPercentage", - "description": "The percentage health of the active boss or bosses at the end of a fight.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "boundingBox", - "description": "The bounding box that encloses the positions of all players\/enemies in the fight.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "ReportMapBoundingBox", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "classicSeasonID", - "description": "The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "completeRaid", - "description": "Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "difficulty", - "description": "The difficulty setting for the raid, dungeon, or arena. Null for trash.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "dungeonPulls", - "description": "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.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportDungeonPull", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "encounterID", - "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "endTime", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enemyNPCs", - "description": "Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportFightNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enemyPets", - "description": "Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportFightNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enemyPlayers", - "description": "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.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "fightPercentage", - "description": "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.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "friendlyNPCs", - "description": "Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportFightNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "friendlyPets", - "description": "Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportFightNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "friendlyPlayers", - "description": "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.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameZone", - "description": "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.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "GameZone", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "hardModeLevel", - "description": "The hard mode level of the fight. Most fights don't support optional hard modes. This only applies to bosses like Sartharion.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "inProgress", - "description": "Whether or not the fight is still in progress. If this field is false, it means the entire fight has been uploaded.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "keystoneAffixes", - "description": "The affixes for a Mythic+ dungeon.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "keystoneBonus", - "description": "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.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "keystoneLevel", - "description": "The keystone level for a Mythic+ dungeon.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "keystoneTime", - "description": "The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "kill", - "description": "Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was a wipe or a failed run, etc..", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "lastPhase", - "description": "The phase that the encounter was in when the fight ended. Counts up from 1 based off the phase type (i.e., normal phase vs intermission).", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "lastPhaseAsAbsoluteIndex", - "description": "The phase that the encounter was in when the fight ended. Always increases from 0, so a fight with three real phases and two intermissions would count up from 0 to 4.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "lastPhaseIsIntermission", - "description": "Whether or not the phase that the encounter was in when the fight ended was an intermission or not.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "layer", - "description": "The layer of a Torghast run.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maps", - "description": "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.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportMap", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "originalEncounterID", - "description": "Some boss fights may be converted to trash fights (encounterID = 0). When this occurs, `originalEncounterID` contains the original ID of the encounter.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "phaseTransitions", - "description": "List of observed phase transitions during the fight.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "PhaseTransition", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rating", - "description": "The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "size", - "description": "The group size for the raid, dungeon, or arena. Null for trash.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "startTime", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "talentImportCode", - "description": "The import\/export code for a Retail Dragonflight talent build. Will be null for a classic or pre-Dragonflight fight.", - "args": [ - { - "name": "actorID", - "description": "The friendly player actor to generate talents for. Result will be null for unknown or non-player actors. Use the ReportMasterData or the friendlyPlayers field on this type to get the list of friendly player actor IDs.", - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "wipeCalledTime", - "description": "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.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportMapBoundingBox", - "description": "The ReportMapBoundingBox is a box that encloses the positions of all players and enemies in a fight or dungeon pull.", - "fields": [ - { - "name": "minX", - "description": "The smallest X position.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maxX", - "description": "The largest X position.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "minY", - "description": "The smallest Y position.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maxY", - "description": "The largest Y position.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportDungeonPull", - "description": "The ReportDungeonPull represents a single pull that occurs in a containing dungeon.", - "fields": [ - { - "name": "boundingBox", - "description": "The bounding box that encloses the positions of all players\/enemies in the fight.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "ReportMapBoundingBox", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "encounterID", - "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "endTime", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enemyNPCs", - "description": "Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportDungeonPullNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "kill", - "description": "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..", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maps", - "description": "All the maps that were involved in a pull.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportMap", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "startTime", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "x", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "y", - "description": "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.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportDungeonPullNPC", - "description": "The ReportDungeonPullNPC represents participation info within a single dungeon pull for an NPC.", - "fields": [ - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameID", - "description": "The game ID of the actor, e.g., so it can be looked up on external Web sites.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "minimumInstanceID", - "description": "The lowest instance ID seen during the pull.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maximumInstanceID", - "description": "The highest instance ID seen during the pull.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "minimumInstanceGroupID", - "description": "The lowest instance group ID seen during the pull.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maximumInstanceGroupID", - "description": "The highest instance group ID seen during the pull.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportMap", - "description": "The ReportMap represents a single map that a fight can occur on.", - "fields": [ - { - "name": "id", - "description": "The map's game ID.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportFightNPC", - "description": "The ReportFightNPC represents participation info within a single fight for an NPC.", - "fields": [ - { - "name": "gameID", - "description": "The game ID of the actor. This ID is used in events to identify sources and targets.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "instanceCount", - "description": "How many instances of the NPC were seen during the fight.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "groupCount", - "description": "How many packs of the NPC were seen during the fight.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "petOwner", - "description": "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.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameZone", - "description": "A single zone for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the zone.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the zone. Will be null if no localization information exists for the zone.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "PhaseTransition", - "description": "A spartan representation of phase transitions during a fight.", - "fields": [ - { - "name": "id", - "description": "The 1-indexed id of the phase. Phase IDs are absolute within a fight: phases with the same ID correspond to the same semantic phase.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "startTime", - "description": "The report-relative timestamp of the transition into the phase. The phase ends at the beginning of the next phase, or at the end of the fight.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "GraphDataType", - "description": "The type of graph to examine.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Summary", - "description": "Summary Overview", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Buffs", - "description": "Buffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Casts", - "description": "Casts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageDone", - "description": "Damage done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageTaken", - "description": "Damage taken.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Deaths", - "description": "Deaths.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Debuffs", - "description": "Debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Dispels", - "description": "Dispels.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Healing", - "description": "Healing done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Interrupts", - "description": "Interrupts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Resources", - "description": "Resources.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Summons", - "description": "Summons", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Survivability", - "description": "Survivability (death info across multiple pulls).", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Threat", - "description": "Threat.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "ViewType", - "description": "Whether the view is by source, target, or ability.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Default", - "description": "Use the same default that the web site picks based off the other selected parameters.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Ability", - "description": "View by ability.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Source", - "description": "View. by source.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Target", - "description": "View by target.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "User", - "description": "A single user of the site. Most fields can only be accessed when authenticated as that user with the \"view-user-profile\" scope.", - "fields": [ - { - "name": "id", - "description": "The ID of the user.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the user.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guilds", - "description": "The list of guilds to which the user belongs. Only accessible via user authentication when you have the \"view-user-profile\" scope.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "characters", - "description": "The characters claimed by this user. Only accessible via user authentication when you have the \"view-user-profile\" scope.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Character", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "battleTag", - "description": "The battle tag of the user if they have linked it.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportMasterData", - "description": "The ReporMastertData object contains information about the log version of a report, as well as the actors and abilities used in the report.", - "fields": [ - { - "name": "logVersion", - "description": "The version of the client parser that was used to parse and upload this log file.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameVersion", - "description": "The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "lang", - "description": "The auto-detected locale of the report. This is the source language of the original log file.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "abilities", - "description": "A list of every ability that occurs in the report.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportAbility", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "actors", - "description": "A list of every actor (player, NPC, pet) that occurs in the report.", - "args": [ - { - "name": "type", - "description": "Optional. A filter on the actors in a report. If the type field of the actor matches the specified type field, it will be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "subType", - "description": "Optional. A filter on the actors in a report. If the subType field of the actor matches the specified subType field, it will be included.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "ReportActor", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportAbility", - "description": "The ReportAbility represents a single ability that occurs in the report.", - "fields": [ - { - "name": "gameID", - "description": "The game ID of the ability.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "An icon to use for the ability.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the actor.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": "The type of the ability. This represents the type of damage (e.g., the spell school in WoW).", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportActor", - "description": "The ReportActor represents a single player, pet or NPC that occurs in the report.", - "fields": [ - { - "name": "gameID", - "description": "The game ID of the actor.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The name of the actor.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "petOwner", - "description": "The report ID of the actor's owner if the actor is a pet.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "server", - "description": "The normalized server name of the actor.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "subType", - "description": "The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": "The type of the actor, i.e., if it is a player, pet or NPC.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "ReportRankingMetricType", - "description": "All the possible metrics.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "bossdps", - "description": "Boss damage per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "bossrdps", - "description": "Boss rDPS is unique to FFXIV and is damage done to the boss adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "default", - "description": "Choose an appropriate default depending on the other selected parameters.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "dps", - "description": "Damage per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "hps", - "description": "Healing per second.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "krsi", - "description": "Survivability ranking for tanks. Deprecated. Only supported for some older WoW zones.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "playerscore", - "description": "Score. Used by WoW Mythic dungeons and by ESO trials.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "playerspeed", - "description": "Speed. Not supported by every zone.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "rdps", - "description": "rDPS is unique to FFXIV and is damage done adjusted for raid-contributing buffs and debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "tankhps", - "description": "Healing done per second to tanks.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "wdps", - "description": "Weighted damage per second. Unique to WoW currently. Used to remove pad damage and reward damage done to high priority targets.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "TableDataType", - "description": "The type of table to examine.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Summary", - "description": "Summary Overview", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Buffs", - "description": "Buffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Casts", - "description": "Casts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageDone", - "description": "Damage done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "DamageTaken", - "description": "Damage taken.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Deaths", - "description": "Deaths.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Debuffs", - "description": "Debuffs.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Dispels", - "description": "Dispels.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Healing", - "description": "Healing done.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Interrupts", - "description": "Interrupts.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Resources", - "description": "Resources.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Summons", - "description": "Summons", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Survivability", - "description": "Survivability (death info across multiple pulls).", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Threat", - "description": "Threat.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportArchiveStatus", - "description": "The archival status of a report.", - "fields": [ - { - "name": "isArchived", - "description": "Whether the report has been archived.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "isAccessible", - "description": "Whether the current user can access the report. Always true if the report is not archived, and always false if not using user authentication.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "archiveDate", - "description": "The date on which the report was archived (if it has been archived).", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "EncounterPhases", - "description": null, - "fields": [ - { - "name": "encounterID", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "separatesWipes", - "description": "Whether this phase splits the fight. Not currently used in Warcraft games.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "phases", - "description": "Phase metadata for all phases in this encounter.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "PhaseMetadata", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "PhaseMetadata", - "description": "Information about a phase from a boss encounter.", - "fields": [ - { - "name": "id", - "description": "Phase ID. 1-indexed", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "isIntermission", - "description": "Whether this phase represents an intermission.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameData", - "description": "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.", - "fields": [ - { - "name": "abilities", - "description": "The player and enemy abilities for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of abilities to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameAbilityPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ability", - "description": "Obtain a single ability for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific ability to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameAbility", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "achievement", - "description": "Obtain a single achievement for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific achievement to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameAchievement", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "achievements", - "description": "Achievements for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of achievements to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameAchievementPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "affix", - "description": "Obtain a single affix for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific affix to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameAffix", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "affixes", - "description": "The affixes for the game.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameAffix", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "class", - "description": "Obtain a single class for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific class to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "faction_id", - "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "zone_id", - "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameClass", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "classes", - "description": "Obtain the supported classes for the game.", - "args": [ - { - "name": "faction_id", - "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "zone_id", - "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameClass", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enchant", - "description": "Obtain a single enchant for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific enchant to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameEnchant", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enchants", - "description": "Enchants for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of enchants to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameEnchantPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "factions", - "description": "Obtain all the factions that guilds and players can belong to.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameFaction", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "item", - "description": "Obtain a single item for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific item to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameItem", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "item_set", - "description": "Obtain a single item set for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific item set to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameItemSet", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "item_sets", - "description": "Item sets for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of item sets to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameItemSetPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "items", - "description": "Items for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of items to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameItemPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "map", - "description": "Obtain a single map for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific map to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameMap", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "maps", - "description": "Maps for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of maps to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameMapPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "npc", - "description": "Obtain a single NPC for the game.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific NPC to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameNPC", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "npcs", - "description": "NPCs for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of NPCs to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameNPCPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zone", - "description": "Obtain a single zone for the game, not to be confused with the worldData zones for ranking bosses and dungeons.", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific game zone to retrieve by its id.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GameZone", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zones", - "description": "Zones for the game.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of game zones to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - } - ], - "type": { - "kind": "OBJECT", - "name": "GameZonePagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameAbilityPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameAbility", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameAbility", - "description": "A single ability for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the ability.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "The icon for the ability.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the ability. Will be null if no localization information exists for the ability.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameAchievement", - "description": "A single achievement for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the achievement.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "The icon for the achievement.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the achievement. Will be null if no localization information exists for the achievement.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameAchievementPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameAchievement", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameAffix", - "description": "A single affix for Mythic Keystone dungeons.", - "fields": [ - { - "name": "id", - "description": "The ID of the affix.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "The icon for the affix.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the affix. Will be null if no localization information exists for the affix.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameClass", - "description": "A single player class for the game.", - "fields": [ - { - "name": "id", - "description": "An integer used to identify the class.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the class.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "slug", - "description": "A slug used to identify the class.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "specs", - "description": "The specs supported by the class.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameSpec", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameSpec", - "description": "A spec for a given player class.", - "fields": [ - { - "name": "id", - "description": "An integer used to identify the spec.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "class", - "description": "The player class that the spec belongs to.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "GameClass", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the class.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "slug", - "description": "A slug used to identify the spec.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameEnchant", - "description": "A single enchant for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the enchant.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the enchant. Will be null if no localization information exists for the enchant.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameEnchantPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameEnchant", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameItem", - "description": "A single item for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the item.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "icon", - "description": "The icon for the item.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the item. Will be null if no localization information exists for the item.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameItemSet", - "description": "A single item set for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the item set.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the item set. Will be null if no localization information exists for the item set.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameItemSetPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameItemSet", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameItemPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameItem", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameMap", - "description": "A single map for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the map.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the map. Will be null if no localization information exists for the map.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameMapPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameMap", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameNPC", - "description": "A single NPC for the game.", - "fields": [ - { - "name": "id", - "description": "The ID of the NPC.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": "The localized name of the NPC. Will be null if no localization information exists for the NPC.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameNPCPagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameNPC", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GameZonePagination", - "description": null, - "fields": [ - { - "name": "data", - "description": "List of items on the current page", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "GameZone", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "from", - "description": "Number of the first item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "to", - "description": "Number of the last item returned", - "args": [], - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "GuildData", - "description": "The GuildData object enables the retrieval of single guilds or filtered collections of guilds.", - "fields": [ - { - "name": "guild", - "description": "Obtain a specific guild either by id or by name\/serverSlug\/serverRegion.", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single guild to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "name", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Guild", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "guilds", - "description": "The set of all guilds supported by the site. Can be optionally filtered to a specific server id.", - "args": [ - { - "name": "limit", - "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "serverID", - "description": "Optional. The ID of a specific server. If present, only guilds from that server (and any connected servers) will be fetched.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Must be used in conjunction with serverRegion to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific server. Must be used in conjunction with serverSlug to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "GuildPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ProgressRaceData", - "description": "A way to obtain data for the top guilds involved in an ongoing world first or realm first progress race.", - "fields": [ - { - "name": "progressRace", - "description": "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.", - "args": [ - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "serverSubregion", - "description": "Optional. The short name of a subregion to filter to. Must be paired with serverRegion. Rankings for that specific subregion will be fetched.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"\"" - }, - { - "name": "zoneID", - "description": "Optional. If not specified, the latest zone will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "competitionID", - "description": "Optional. If not specified, the race to world first competition will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "difficulty", - "description": "Optional. If not specified, the highest difficulty will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "size", - "description": "Optional. If not specified, the default size for the highest difficulty will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "guildID", - "description": "Optional. The ID of a single guild to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "detailedComposition", - "description": "Detailed composition data for a given guild and encounter.", - "args": [ - { - "name": "competitionID", - "description": "Optional. If not specified, the race to world first competition will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "guildID", - "description": "Optional. The ID of a single guild to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "encounterID", - "description": "Optional. If not specified, the current boss that is being pulled will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "difficulty", - "description": "Optional. If not specified, the highest difficulty will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "size", - "description": "Optional. If not specified, the default size for the highest difficulty will be used.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "RateLimitData", - "description": "A way to obtain your current rate limit usage.", - "fields": [ - { - "name": "limitPerHour", - "description": "The total amount of points this API key can spend per hour.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "pointsSpentThisHour", - "description": "The total amount of points spent during this hour.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "pointsResetIn", - "description": "The number of seconds remaining until the points reset.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ReportData", - "description": "The ReportData object enables the retrieval of single reports or filtered collections of reports.", - "fields": [ - { - "name": "report", - "description": "Obtain a specific report by its code.", - "args": [ - { - "name": "code", - "description": "Required. The code of a single report to retrieve.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Report", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "reports", - "description": "A set of reports for a specific guild, guild tag, or user.", - "args": [ - { - "name": "endTime", - "description": "Optional. A UNIX timestamp with millisecond precision representing the end time for a report range. If omitted, defaults to the current time in milliseconds.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildID", - "description": "Optional. The ID of a specific guild. Reports from that guild will be fetched.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with guildServerSlug and guildServerRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildServerSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildServerRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "guildTagID", - "description": "Optional. The ID of a specific guild tag. Reports from that guild tag will be fetched. This will take precedence over all other guild arguments.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "userID", - "description": "Optional. The ID of a specific user. Reports from that user's personal logs will be fetched.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "100" - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "1" - }, - { - "name": "startTime", - "description": "Optional. A UNIX timestamp with millisecond precision representing a start time for a report range. If omitted, defaults to 0.", - "type": { - "kind": "SCALAR", - "name": "Float", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "zoneID", - "description": "Optional. The ID of a specific zone to filter to. Reports with that zone as their default will be included.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - }, - { - "name": "gameZoneID", - "description": "Optional. The ID of a specific game zone to filter reports to.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": "0" - } - ], - "type": { - "kind": "OBJECT", - "name": "ReportPagination", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "UserData", - "description": "The user data object contains basic information about users and lets you retrieve specific users (or the current user if using the user endpoint).", - "fields": [ - { - "name": "user", - "description": "Obtain a specific user by id.", - "args": [ - { - "name": "id", - "description": "Required. Specify a single user ID to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "User", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "currentUser", - "description": "Obtain the current user (only works with user endpoint).", - "args": [], - "type": { - "kind": "OBJECT", - "name": "User", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "WorldData", - "description": "The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc.", - "fields": [ - { - "name": "encounter", - "description": "Obtain a specific encounter by id.", - "args": [ - { - "name": "id", - "description": "Required. Specify a single encounter ID to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Encounter", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "expansion", - "description": "A single expansion obtained by ID.", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single expansion to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Expansion", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "expansions", - "description": "The set of all expansions supported by the site.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Expansion", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "region", - "description": "Obtain a specific region by its ID.", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single region to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Region", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "regions", - "description": "The set of all regions supported by the site.", - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Region", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "server", - "description": "Obtain a specific server either by id or by slug and region.", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single server to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "region", - "description": "Optional. The compact English abbreviation for a specific region (e.g., \"US\"). Use in conjunction with the server slug to retrieve a single server.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "slug", - "description": "Optional. A server slug. Use in conjunction with the server region to retrieve a single server.", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Server", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "subregion", - "description": "Obtain a specific subregion by its ID.", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single subregion to retrieve.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Subregion", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zone", - "description": "Obtain a specific zone by its ID.", - "args": [ - { - "name": "id", - "description": "Required. The ID of a specific zone.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "zones", - "description": "Obtain a set of all zones supported by the site.", - "args": [ - { - "name": "expansion_id", - "description": "Optional. The ID of a specific expansion. If omitted, the zones from all expansions will be retrieved.", - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "Zone", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "SCALAR", - "name": "ID", - "description": "The `ID` scalar type represents a unique identifier, often used to\nrefetch an object or as key for a cache. The ID type appears in a JSON\nresponse as a String; however, it is not intended to be human-readable.\nWhen expected as an input type, any string (such as `\"4\"`) or integer\n(such as `4`) input value will be accepted as an ID.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__Schema", - "description": "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.", - "fields": [ - { - "name": "types", - "description": "A list of all types supported by this server.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "queryType", - "description": "The type that query operations will be rooted at.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "mutationType", - "description": "If this server supports mutation, the type that mutation operations will be rooted at.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "subscriptionType", - "description": "If this server support subscription, the type that subscription operations will be rooted at.", - "args": [], - "type": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "directives", - "description": "A list of all directives supported by this server.", - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Directive", - "ofType": null - } - } - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__Type", - "description": "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name and description, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.", - "fields": [ - { - "name": "kind", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "ENUM", - "name": "__TypeKind", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "fields", - "description": null, - "args": [ - { - "name": "includeDeprecated", - "description": null, - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Field", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "interfaces", - "description": null, - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "possibleTypes", - "description": null, - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "enumValues", - "description": null, - "args": [ - { - "name": "includeDeprecated", - "description": null, - "type": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - }, - "defaultValue": "false" - } - ], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__EnumValue", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "inputFields", - "description": null, - "args": [], - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__InputValue", - "ofType": null - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ofType", - "description": null, - "args": [], - "type": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "__TypeKind", - "description": "An enum describing what kind of type a given `__Type` is.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "SCALAR", - "description": "Indicates this type is a scalar.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "OBJECT", - "description": "Indicates this type is an object. `fields` and `interfaces` are valid fields.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INTERFACE", - "description": "Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "UNION", - "description": "Indicates this type is a union. `possibleTypes` is a valid field.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ENUM", - "description": "Indicates this type is an enum. `enumValues` is a valid field.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INPUT_OBJECT", - "description": "Indicates this type is an input object. `inputFields` is a valid field.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "LIST", - "description": "Indicates this type is a list. `ofType` is a valid field.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "NON_NULL", - "description": "Indicates this type is a non-null. `ofType` is a valid field.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__Field", - "description": "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.", - "fields": [ - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "args", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__InputValue", - "ofType": null - } - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "isDeprecated", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "deprecationReason", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__InputValue", - "description": "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.", - "fields": [ - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "type", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__Type", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "defaultValue", - "description": "A GraphQL-formatted string representing the default value for this input value.", - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__EnumValue", - "description": "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.", - "fields": [ - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "isDeprecated", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "deprecationReason", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "__Directive", - "description": "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.", - "fields": [ - { - "name": "name", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "description", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "args", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "OBJECT", - "name": "__InputValue", - "ofType": null - } - } - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "isRepeatable", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "locations", - "description": null, - "args": [], - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "ENUM", - "name": "__DirectiveLocation", - "ofType": null - } - } - } - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "__DirectiveLocation", - "description": "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "QUERY", - "description": "Location adjacent to a query operation.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "MUTATION", - "description": "Location adjacent to a mutation operation.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "SUBSCRIPTION", - "description": "Location adjacent to a subscription operation.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "FIELD", - "description": "Location adjacent to a field.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "FRAGMENT_DEFINITION", - "description": "Location adjacent to a fragment definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "FRAGMENT_SPREAD", - "description": "Location adjacent to a fragment spread.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INLINE_FRAGMENT", - "description": "Location adjacent to an inline fragment.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "VARIABLE_DEFINITION", - "description": "Location adjacent to a variable definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "SCHEMA", - "description": "Location adjacent to a schema definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "SCALAR", - "description": "Location adjacent to a scalar definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "OBJECT", - "description": "Location adjacent to an object type definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "FIELD_DEFINITION", - "description": "Location adjacent to a field definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ARGUMENT_DEFINITION", - "description": "Location adjacent to an argument definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INTERFACE", - "description": "Location adjacent to an interface definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "UNION", - "description": "Location adjacent to a union definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ENUM", - "description": "Location adjacent to an enum definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ENUM_VALUE", - "description": "Location adjacent to an enum value definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INPUT_OBJECT", - "description": "Location adjacent to an input object type definition.", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "INPUT_FIELD_DEFINITION", - "description": "Location adjacent to an input object field definition.", - "isDeprecated": false, - "deprecationReason": null - } - ], - "possibleTypes": null - }, - { - "kind": "OBJECT", - "name": "ArchonViewModels", - "description": null, - "fields": [ - { - "name": "googleAnalytics", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "game", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "translations", - "description": null, - "args": [ - { - "name": "keys", - "description": null, - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "header", - "description": null, - "args": [ - { - "name": "gameSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "headerTitle", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "footer", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "indexPage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gamePage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "contactPage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "aboutPage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "announcementPage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "gameSlugs", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "buildsZonePageSlugs", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "buildsZonePage", - "description": null, - "args": [ - { - "name": "gameSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "rankingsSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "zoneTypeSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "difficultySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "encounterSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "affixesSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "buildsSpecPageSlugs", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "buildsSpecPage", - "description": null, - "args": [ - { - "name": "gameSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "classSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "specSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "zoneTypeSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "categorySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "difficultySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "encounterSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "affixesSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "buildsClassesAndSpecsPage", - "description": null, - "args": [ - { - "name": "gameSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "ability", - "description": null, - "args": [ - { - "name": "id", - "description": null, - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "articleCategory", - "description": null, - "args": [ - { - "name": "articleCategorySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "articleCategories", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "articleSlugs", - "description": null, - "args": [ - { - "name": "articleCategorySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "siteName", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "article", - "description": null, - "args": [ - { - "name": "articleSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "articleCategorySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "siteName", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "cmsNavigation", - "description": null, - "args": [ - { - "name": "currentSlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "pageOfArticlePreviews", - "description": null, - "args": [ - { - "name": "articleCategorySlug", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "pageNumber", - "description": null, - "type": { - "kind": "SCALAR", - "name": "Int", - "ofType": null - }, - "defaultValue": null - }, - { - "name": "siteName", - "description": null, - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "snippets", - "description": null, - "args": [ - { - "name": "snippetSlugs", - "description": null, - "type": { - "kind": "LIST", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "String", - "ofType": null - } - }, - "defaultValue": null - } - ], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "articleIndexPage", - "description": null, - "args": [], - "type": { - "kind": "SCALAR", - "name": "JSON", - "ofType": null - }, - "isDeprecated": false, - "deprecationReason": null - } - ], - "inputFields": null, - "interfaces": [], - "enumValues": null, - "possibleTypes": null - }, - { - "kind": "ENUM", - "name": "SubscriptionStatus", - "description": "The type of Subscription.", - "fields": null, - "inputFields": null, - "interfaces": null, - "enumValues": [ - { - "name": "Silver", - "description": "Silver Tier subscription", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Gold", - "description": "Gold Tier subscription", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "Platinum", - "description": "Platinum Tier subscription", - "isDeprecated": false, - "deprecationReason": null - }, - { - "name": "LegacySilver", - "description": "Legacy Silver Tier subscription", - "isDeprecated": true, - "deprecationReason": "Legacy Silver subscriptions are not available for new users." - }, - { - "name": "LegacyGold", - "description": "Legacy Gold Tier subscription", - "isDeprecated": true, - "deprecationReason": "Legacy Gold subscriptions are not available for new users." - }, - { - "name": "LegacyPlatinum", - "description": "Legacy Platinum Tier subscription", - "isDeprecated": true, - "deprecationReason": "Legacy Platinum subscriptions are not available for new users." - } - ], - "possibleTypes": null - } - ], - "directives": [ - { - "name": "include", - "description": "Directs the executor to include this field or fragment only when the `if` argument is true.", - "locations": [ - "FIELD", - "FRAGMENT_SPREAD", - "INLINE_FRAGMENT" - ], - "args": [ - { - "name": "if", - "description": "Included when true.", - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "defaultValue": null - } - ] - }, - { - "name": "skip", - "description": "Directs the executor to skip this field or fragment when the `if` argument is true.", - "locations": [ - "FIELD", - "FRAGMENT_SPREAD", - "INLINE_FRAGMENT" - ], - "args": [ - { - "name": "if", - "description": "Skipped when true.", - "type": { - "kind": "NON_NULL", - "name": null, - "ofType": { - "kind": "SCALAR", - "name": "Boolean", - "ofType": null - } - }, - "defaultValue": null - } - ] - }, - { - "name": "deprecated", - "description": "Marks an element of a GraphQL schema as no longer supported.", - "locations": [ - "FIELD_DEFINITION", - "ENUM_VALUE" - ], - "args": [ - { - "name": "reason", - "description": "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax (as specified by [CommonMark](https:\/\/commonmark.org\/).", - "type": { - "kind": "SCALAR", - "name": "String", - "ofType": null - }, - "defaultValue": "\"No longer supported\"" - } - ] - } - ] - } - } -} diff --git a/wcl/types/__init__.py b/wcl/types/__init__.py index 97b89bd..aa4d9d7 100644 --- a/wcl/types/__init__.py +++ b/wcl/types/__init__.py @@ -1,8 +1,4 @@ -# from . import enum, object, scalar -from . import enum -from . import scalar -# from . import object - -""" -asdf -""" +from .primitives import GQL_NON_NULL, GQL_LIST +from .enums import * +from .scalars import * +from .objects import * diff --git a/wcl/types/enum.py b/wcl/types/enums.py similarity index 99% rename from wcl/types/enum.py rename to wcl/types/enums.py index 4dc2b35..53b524e 100644 --- a/wcl/types/enum.py +++ b/wcl/types/enums.py @@ -1,8 +1,8 @@ -from ..query import GQL_ENUM +from .primitives import GQL_ENUM """ ENUM TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. +THIS FILE IS GENERATED BY `wcl/__main__.py`. """ class GQL_RankingCompareType( GQL_ENUM ): diff --git a/wcl/types/object.py b/wcl/types/object.py deleted file mode 100644 index 98db19f..0000000 --- a/wcl/types/object.py +++ /dev/null @@ -1,4227 +0,0 @@ -from ..query import * -from .enum import * -from .scalar import * - -""" -OBJECT TYPES -THIS FILE IS GENERATED BY `wcl/query.py`. -""" - -class GQL_Query( GQL_OBJECT ): - fields = [ - { - "name": "characterData", - "description": "Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.", - "type": "GQL_CharacterData", - }, - { - "name": "gameData", - "description": "Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..", - "type": "GQL_GameData", - }, - { - "name": "guildData", - "description": "Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.", - "type": "GQL_GuildData", - }, - { - "name": "progressRaceData", - "description": "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.", - "type": "GQL_ProgressRaceData", - }, - { - "name": "rateLimitData", - "description": "Obtain the rate limit data object to see how many points have been spent by this key.", - "type": "GQL_RateLimitData", - }, - { - "name": "reportData", - "description": "Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.", - "type": "GQL_ReportData", - }, - { - "name": "userData", - "description": "Obtain the user object that allows the retrieval of the authorized user's id and username.", - "type": "GQL_UserData", - }, - { - "name": "worldData", - "description": "Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon/raid zones, and encounters.", - "type": "GQL_WorldData", - }, - ] - -class GQL_CharacterData( GQL_OBJECT ): - fields = [ - { - "name": "character", - "description": "Obtain a specific character either by id or by name/server_slug/server_region.", - "type": "GQL_Character", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single character to retrieve.", - "type": GQL_Int, - }, - { - "name": "name", - "description": "Optional. The name of a specific character. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a character.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The slug of a specific server. Must be used in conjunction with name and serverRegion to uniquely identify a character.", - "type": GQL_String, - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific character. Must be used in conjunction with name and serverRegion to uniquely identify a character.", - "type": GQL_String, - }, - ] - }, - { - "name": "characters", - "description": "A collection of characters for a specific guild.", - "type": "GQL_CharacterPagination", - "args": [ - { - "name": "guildID", - "description": "Required. The ID of a specific guild. Characters from that guild will be fetched.", - "type": GQL_Int, - }, - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_Character( GQL_OBJECT ): - fields = [ - { - "name": "canonicalID", - "description": "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.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "claimed", - "description": "Whether this character is claimed by the current user. Only accessible if accessed via the user API with the "view-user-profile" scope.", - "type": GQL_Boolean, - }, - { - "name": "classID", - "description": "The class id of the character.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "encounterRankings", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "byBracket", - "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": GQL_Boolean, - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", - "type": GQL_String, - }, - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": GQL_RankingCompareType, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Required. The specific encounter whose rankings should be fetched.", - "type": GQL_Int, - }, - { - "name": "includeCombatantInfo", - "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", - "type": GQL_Boolean, - }, - { - "name": "includePrivateLogs", - "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", - "type": GQL_Boolean, - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", - "type": GQL_CharacterRankingMetricType, - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", - "type": GQL_Int, - }, - { - "name": "role", - "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", - "type": GQL_RoleType, - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": GQL_Int, - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": GQL_String, - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": GQL_RankingTimeframeType, - }, - ] - }, - { - "name": "faction", - "description": "The faction of the character.", - "type": GQL_NON_NULL("GQL_GameFaction"), - }, - { - "name": "gameData", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "specID", - "description": "Optional. A specific spec ID to retrieve information for. If omitted, the last observed spec on Armory (WoW) or Lodestone (FF) will be used.", - "type": GQL_Int, - }, - { - "name": "forceUpdate", - "description": "Optional. Whether or not to force the updating of the character before returning the game data.", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "guildRank", - "description": "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.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "guilds", - "description": "All guilds that the character belongs to.", - "type": GQL_LIST("GQL_Guild"), - }, - { - "name": "hidden", - "description": "Whether or not the character has all its rankings hidden.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "id", - "description": "The ID of the character.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "level", - "description": "The level of the character.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The name of the character.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "recentReports", - "description": "Recent reports for the character.", - "type": "GQL_ReportPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of recent reports to retrieve. If omitted, defaults to 10. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "server", - "description": "The server that the character belongs to.", - "type": GQL_NON_NULL("GQL_Server"), - }, - { - "name": "zoneRankings", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "byBracket", - "description": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": GQL_Boolean, - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", - "type": GQL_String, - }, - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": GQL_RankingCompareType, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", - "type": GQL_Int, - }, - { - "name": "includePrivateLogs", - "description": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", - "type": GQL_Boolean, - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", - "type": GQL_CharacterRankingMetricType, - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", - "type": GQL_Int, - }, - { - "name": "role", - "description": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", - "type": GQL_RoleType, - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": GQL_Int, - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": GQL_String, - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": GQL_RankingTimeframeType, - }, - { - "name": "zoneID", - "description": "Optional. If not specified, the latest unfrozen zone will be used.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_GameFaction( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "An integer representing the faction id.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the faction.", - "type": GQL_NON_NULL(GQL_String), - }, - ] - -class GQL_Guild( GQL_OBJECT ): - fields = [ - { - "name": "attendance", - "description": "None", - "type": GQL_NON_NULL("GQL_GuildAttendancePagination"), - "args": [ - { - "name": "guildTagID", - "description": "Optional. Whether or not to filter the attendance to a specific guild tag.", - "type": GQL_Int, - }, - { - "name": "limit", - "description": "Optional. The number of reports to retrieve per page. If omitted, defaults to 16. The maximum allowed value is 25, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - { - "name": "zoneID", - "description": "Optional. Whether or not to filter the attendance table to a specific zone.", - "type": GQL_Int, - }, - ] - }, - { - "name": "competitionMode", - "description": "Whether or not the guild has competition mode enabled.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "description", - "description": "The description for the guild that is displayed with the guild name on the site.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "faction", - "description": "The faction of the guild.", - "type": GQL_NON_NULL("GQL_GameFaction"), - }, - { - "name": "id", - "description": "The ID of the guild.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The name of the guild.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "server", - "description": "The server that the guild belongs to.", - "type": GQL_NON_NULL("GQL_Server"), - }, - { - "name": "stealthMode", - "description": "Whether or not the guild has stealth mode enabled.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "tags", - "description": "The tags used to label reports. In the site UI, these are called raid teams.", - "type": GQL_LIST("GQL_GuildTag"), - }, - { - "name": "members", - "description": "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.", - "type": GQL_NON_NULL("GQL_CharacterPagination"), - "args": [ - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "currentUserRank", - "description": "The current user's rank within the guild. Only accessible via user authentication with the "view-user-profile" scope.", - "type": GQL_GuildRank, - }, - { - "name": "zoneRanking", - "description": "The guild's ranking for a zone. If `zoneId` is unset or null, uses the latest zone.", - "type": GQL_NON_NULL("GQL_GuildZoneRankings"), - "args": [ - { - "name": "zoneId", - "description": "None", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_GuildAttendancePagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GuildAttendance"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GuildAttendance( GQL_OBJECT ): - fields = [ - { - "name": "code", - "description": "The code of the report for the raid night.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "players", - "description": "The players that attended that raid night.", - "type": GQL_LIST("GQL_PlayerAttendance"), - }, - { - "name": "startTime", - "description": "The start time of the raid night.", - "type": GQL_Float, - }, - { - "name": "zone", - "description": "The principal zone of the raid night.", - "type": "GQL_Zone", - }, - ] - -class GQL_PlayerAttendance( GQL_OBJECT ): - fields = [ - { - "name": "name", - "description": "The name of the player.", - "type": GQL_String, - }, - { - "name": "type", - "description": "The class of the player.", - "type": GQL_String, - }, - { - "name": "presence", - "description": "Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.", - "type": GQL_Int, - }, - ] - -class GQL_Zone( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the zone.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "brackets", - "description": "The bracket information for this zone. This field will be null if the zone does not support brackets.", - "type": "GQL_Bracket", - }, - { - "name": "difficulties", - "description": "A list of all the difficulties supported for this zone.", - "type": GQL_LIST("GQL_Difficulty"), - }, - { - "name": "encounters", - "description": "The encounters found within this zone.", - "type": GQL_LIST("GQL_Encounter"), - }, - { - "name": "expansion", - "description": "The expansion that this zone belongs to.", - "type": GQL_NON_NULL("GQL_Expansion"), - }, - { - "name": "frozen", - "description": "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.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "name", - "description": "The name of the zone.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "partitions", - "description": "A list of all the partitions supported for this zone.", - "type": GQL_LIST("GQL_Partition"), - }, - ] - -class GQL_Bracket( GQL_OBJECT ): - fields = [ - { - "name": "min", - "description": "An integer representing the minimum value used by bracket number 1, etc.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "max", - "description": "An integer representing the value used by bracket N when there are a total of N brackets, etc.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "bucket", - "description": "A float representing the value to increment when moving from bracket 1 to bracket N, etc.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "type", - "description": "The localized name of the bracket type.", - "type": GQL_String, - }, - ] - -class GQL_Difficulty( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "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.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name for the difficulty level.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "sizes", - "description": "A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.", - "type": GQL_LIST(GQL_Int), - }, - ] - -class GQL_Encounter( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the encounter.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the encounter.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "characterRankings", - "description": "Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", - "type": GQL_JSON, - "args": [ - { - "name": "bracket", - "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", - "type": GQL_Int, - }, - { - "name": "filter", - "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", - "type": GQL_String, - }, - { - "name": "page", - "description": "Optional. Which page of rankings to fetch. By default the first page is used.", - "type": GQL_Int, - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", - "type": GQL_Int, - }, - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": GQL_String, - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": GQL_Int, - }, - { - "name": "leaderboard", - "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", - "type": GQL_LeaderboardRank, - }, - { - "name": "hardModeLevel", - "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", - "type": GQL_HardModeLevelRankFilter, - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific player metric like dps or hps. If omitted, an appropriate default player metric for the zone will be chosen.", - "type": GQL_CharacterRankingMetricType, - }, - { - "name": "includeCombatantInfo", - "description": "Optional. Whether or not to include detailed combatant info such as gear in the results.", - "type": GQL_Boolean, - }, - { - "name": "className", - "description": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. If omitted, data for all classes will be used.", - "type": GQL_String, - }, - { - "name": "specName", - "description": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", - "type": GQL_String, - }, - { - "name": "externalBuffs", - "description": "Optional. Controls whether to include ranks with/without external buffs. Most games and zones do not support this filter and will quietly ignore it.", - "type": GQL_ExternalBuffRankFilter, - }, - { - "name": "covenantID", - "description": "Optional. The covenant ID to filter to if viewing Shadowlands rankings.", - "type": GQL_Int, - }, - { - "name": "soulbindID", - "description": "Optional. The soulbind ID to filter to if viewing Shadowlands rankings.", - "type": GQL_Int, - }, - ] - }, - { - "name": "fightRankings", - "description": "Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", - "type": GQL_JSON, - "args": [ - { - "name": "bracket", - "description": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", - "type": GQL_Int, - }, - { - "name": "filter", - "description": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", - "type": GQL_String, - }, - { - "name": "page", - "description": "Optional. Which page of rankings to fetch. By default the first page is used.", - "type": GQL_Int, - }, - { - "name": "partition", - "description": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", - "type": GQL_Int, - }, - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": GQL_String, - }, - { - "name": "size", - "description": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", - "type": GQL_Int, - }, - { - "name": "leaderboard", - "description": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", - "type": GQL_LeaderboardRank, - }, - { - "name": "hardModeLevel", - "description": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", - "type": GQL_HardModeLevelRankFilter, - }, - { - "name": "metric", - "description": "Optional. You can filter to a specific fight metric like speed or execution. If omitted, an appropriate default fight metric for the zone will be chosen.", - "type": GQL_FightRankingMetricType, - }, - ] - }, - { - "name": "zone", - "description": "The zone that this encounter is found in.", - "type": GQL_NON_NULL("GQL_Zone"), - }, - { - "name": "journalID", - "description": "The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_Expansion( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the expansion.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the expansion.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "zones", - "description": "The zones (e.g., raids and dungeons) supported for this expansion.", - "type": GQL_LIST("GQL_Zone"), - }, - ] - -class GQL_Partition( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "An integer representing a specific partition within a zone.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name for partition.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "compactName", - "description": "The compact localized name for the partition. Typically an abbreviation to conserve space.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "default", - "description": "Whether or not the partition is the current default when viewing rankings or statistics for the zone.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_Server( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the server.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The name of the server in the locale of the subregion that the server belongs to.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "normalizedName", - "description": "The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "slug", - "description": "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.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "region", - "description": "The region that this server belongs to.", - "type": GQL_NON_NULL("GQL_Region"), - }, - { - "name": "subregion", - "description": "The subregion that this server belongs to.", - "type": GQL_NON_NULL("GQL_Subregion"), - }, - { - "name": "guilds", - "description": "The guilds found on this server (and any servers connected to this one.", - "type": "GQL_GuildPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of guilds to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "characters", - "description": "The characters found on this server (and any servers connected to this one.", - "type": "GQL_CharacterPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_Region( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the region.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "compactName", - "description": "The localized compact name of the region, e.g., US for United States.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "name", - "description": "The localized name of the region.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "slug", - "description": "The slug for the region, usable when looking up characters and guilds by server.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "subregions", - "description": "The subregions found within this region.", - "type": GQL_LIST("GQL_Subregion"), - }, - { - "name": "servers", - "description": "The servers found within this region.", - "type": "GQL_ServerPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_Subregion( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the subregion.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the subregion.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "region", - "description": "The region that this subregion is found in.", - "type": GQL_NON_NULL("GQL_Region"), - }, - { - "name": "servers", - "description": "The servers found within this region.", - "type": "GQL_ServerPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_ServerPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_Server"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GuildPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_Guild"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_CharacterPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_Character"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GuildTag( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the tag.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "guild", - "description": "The guild that the tag belongs to.", - "type": GQL_NON_NULL("GQL_Guild"), - }, - { - "name": "name", - "description": "The name of the tag.", - "type": GQL_NON_NULL(GQL_String), - }, - ] - -class GQL_GuildZoneRankings( GQL_OBJECT ): - fields = [ - { - "name": "progress", - "description": "The progress ranks for the guild. Always uses the highest difficulty.", - "type": "GQL_WorldRegionServerRankPositions", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": GQL_Int, - }, - ] - }, - { - "name": "speed", - "description": "The all-star based speed rank for the guild.", - "type": "GQL_WorldRegionServerRankPositions", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Raid difficulty.", - "type": GQL_Int, - }, - ] - }, - { - "name": "completeRaidSpeed", - "description": "The complete raid speed ranks for the guild. Most non-Classic WoW zones do not support complete raid ranks.", - "type": "GQL_WorldRegionServerRankPositions", - "args": [ - { - "name": "size", - "description": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Raid difficulty.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_WorldRegionServerRankPositions( GQL_OBJECT ): - fields = [ - { - "name": "worldRank", - "description": "None", - "type": "GQL_Rank", - }, - { - "name": "regionRank", - "description": "None", - "type": "GQL_Rank", - }, - { - "name": "serverRank", - "description": "None", - "type": "GQL_Rank", - }, - ] - -class GQL_Rank( GQL_OBJECT ): - fields = [ - { - "name": "number", - "description": "The ordinal rank (usually written "Rank N"). Rank 1 = highest.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "percentile", - "description": "The percentile of the rank as an integer in [0, 100]. Always null for guild ranks.", - "type": GQL_Int, - }, - { - "name": "color", - "description": "The color class used by the site for this rank.", - "type": GQL_NON_NULL(GQL_String), - }, - ] - -class GQL_ReportPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_Report"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_Report( GQL_OBJECT ): - fields = [ - { - "name": "code", - "description": "The report code, a unique value used to identify the report.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "endTime", - "description": "The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "events", - "description": "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.", - "type": "GQL_ReportEventPaginator", - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": GQL_Float, - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": GQL_EventDataType, - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": GQL_String, - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": GQL_HostilityType, - }, - { - "name": "includeResources", - "description": "Optional. Whether or not to include detailed unit resources for actors. Adds substantially to bandwidth, so defaults to off.", - "type": GQL_Boolean, - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": GQL_KillType, - }, - { - "name": "limit", - "description": "Optional. How many events to retrieve. Allowed value ranges are 100-10000. The default value is 300.", - "type": GQL_Int, - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": GQL_Int, - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": GQL_Int, - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if is a priority, and you do not care about the names.", - "type": GQL_Boolean, - }, - { - "name": "useAbilityIDs", - "description": "Optional. Whether or not to include detailed ability information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", - "type": GQL_Boolean, - }, - { - "name": "useActorIDs", - "description": "Optional. Whether or not to include detailed actor information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", - "type": GQL_Boolean, - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": GQL_Int, - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": GQL_Int, - }, - ] - }, - { - "name": "exportedSegments", - "description": "The number of exported segments in the report. This is how many segments have been processed for rankings.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "fights", - "description": "A set of fights with details about participating players.", - "type": GQL_LIST("GQL_ReportFight"), - "args": [ - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": GQL_KillType, - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "graph", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": GQL_Float, - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": GQL_GraphDataType, - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": GQL_String, - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": GQL_HostilityType, - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": GQL_KillType, - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": GQL_Int, - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": GQL_Int, - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": GQL_Boolean, - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": GQL_Int, - }, - { - "name": "viewBy", - "description": "Optional. Whether to view by source, by target or by ability.", - "type": GQL_ViewType, - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": GQL_Int, - }, - ] - }, - { - "name": "guild", - "description": "The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.", - "type": "GQL_Guild", - }, - { - "name": "guildTag", - "description": "The guild tag that the report belongs to. If this is null, then the report was not tagged.", - "type": "GQL_GuildTag", - }, - { - "name": "owner", - "description": "The user that uploaded the report.", - "type": "GQL_User", - }, - { - "name": "masterData", - "description": "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.", - "type": "GQL_ReportMasterData", - "args": [ - { - "name": "translate", - "description": "Optional. Whether or not the actors and abilities in the master data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names of abilities and actors.", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "playerDetails", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": GQL_KillType, - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "rankedCharacters", - "description": "A list of all characters that ranked on kills in the report.", - "type": GQL_LIST("GQL_Character"), - }, - { - "name": "rankings", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "compare", - "description": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", - "type": GQL_RankingCompareType, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "playerMetric", - "description": "Optional. You can filter to a specific player metric like dps or hps.", - "type": GQL_ReportRankingMetricType, - }, - { - "name": "timeframe", - "description": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", - "type": GQL_RankingTimeframeType, - }, - ] - }, - { - "name": "region", - "description": "The region of the report.", - "type": "GQL_Region", - }, - { - "name": "revision", - "description": "The revision of the report. This number is increased when reports get re-exported.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "segments", - "description": "The number of uploaded segments in the report.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "startTime", - "description": "The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "table", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "abilityID", - "description": "Optional. The game id of a specific ability to filter to.", - "type": GQL_Float, - }, - { - "name": "dataType", - "description": "Optional. You can filter to a specific subset of events.", - "type": GQL_TableDataType, - }, - { - "name": "death", - "description": "Optional. If viewing death events, a specific death to obtain information for.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "encounterID", - "description": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", - "type": GQL_Int, - }, - { - "name": "endTime", - "description": "Optional. The end time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "fightIDs", - "description": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "filterExpression", - "description": "Optional. An expression in the site's query language that will be applied as a filter to the events.", - "type": GQL_String, - }, - { - "name": "hostilityType", - "description": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", - "type": GQL_HostilityType, - }, - { - "name": "killType", - "description": "Optional. A filter to only include kills, wipes, encounters or trash.", - "type": GQL_KillType, - }, - { - "name": "sourceAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceAurasPresent", - "description": "A comma-separated list of auras that must be present on the source for the event to be included.", - "type": GQL_String, - }, - { - "name": "sourceClass", - "description": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "sourceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", - "type": GQL_Int, - }, - { - "name": "sourceInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "startTime", - "description": "Optional. The start time of the events range to fetch.", - "type": GQL_Float, - }, - { - "name": "targetAurasAbsent", - "description": "A comma-separated list of auras that must be absent on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetAurasPresent", - "description": "A comma-separated list of auras that must be present on the target for the event to be included.", - "type": GQL_String, - }, - { - "name": "targetClass", - "description": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", - "type": GQL_String, - }, - { - "name": "targetID", - "description": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", - "type": GQL_Int, - }, - { - "name": "targetInstanceID", - "description": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", - "type": GQL_Int, - }, - { - "name": "translate", - "description": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", - "type": GQL_Boolean, - }, - { - "name": "viewOptions", - "description": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", - "type": GQL_Int, - }, - { - "name": "viewBy", - "description": "Optional. Whether to view by source, by target or by ability.", - "type": GQL_ViewType, - }, - { - "name": "wipeCutoff", - "description": "Optional. The number of deaths after which all subsequent events should be ignored.", - "type": GQL_Int, - }, - ] - }, - { - "name": "title", - "description": "A title for the report.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "visibility", - "description": "The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "zone", - "description": "The principal zone that the report contains fights for. Null if no supported zone exists.", - "type": "GQL_Zone", - }, - { - "name": "archiveStatus", - "description": "Whether this report has been archived. Events, tables, and graphs for archived reports are inaccessible unless the retrieving user has a subscription including archive access.", - "type": "GQL_ReportArchiveStatus", - }, - { - "name": "phases", - "description": "Phase information for all boss encounters observed in this report. This requires loading fight data, but does not double-charge API points if you load fights and phases.", - "type": GQL_LIST(GQL_NON_NULL("GQL_EncounterPhases")), - }, - ] - -class GQL_ReportEventPaginator( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "The list of events obtained.", - "type": GQL_JSON, - }, - { - "name": "nextPageTimestamp", - "description": "A timestamp to pass in as the start time when fetching the next page of data.", - "type": GQL_Float, - }, - ] - -class GQL_ReportFight( GQL_OBJECT ): - fields = [ - { - "name": "averageItemLevel", - "description": "The average item level of the players in the fight.", - "type": GQL_Float, - }, - { - "name": "bossPercentage", - "description": "The percentage health of the active boss or bosses at the end of a fight.", - "type": GQL_Float, - }, - { - "name": "boundingBox", - "description": "The bounding box that encloses the positions of all players/enemies in the fight.", - "type": "GQL_ReportMapBoundingBox", - }, - { - "name": "classicSeasonID", - "description": "The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.", - "type": GQL_Int, - }, - { - "name": "completeRaid", - "description": "Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "difficulty", - "description": "The difficulty setting for the raid, dungeon, or arena. Null for trash.", - "type": GQL_Int, - }, - { - "name": "dungeonPulls", - "description": "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.", - "type": GQL_LIST("GQL_ReportDungeonPull"), - }, - { - "name": "encounterID", - "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "endTime", - "description": "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.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "enemyNPCs", - "description": "Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "type": GQL_LIST("GQL_ReportFightNPC"), - }, - { - "name": "enemyPets", - "description": "Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", - "type": GQL_LIST("GQL_ReportFightNPC"), - }, - { - "name": "enemyPlayers", - "description": "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.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "fightPercentage", - "description": "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.", - "type": GQL_Float, - }, - { - "name": "friendlyNPCs", - "description": "Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "type": GQL_LIST("GQL_ReportFightNPC"), - }, - { - "name": "friendlyPets", - "description": "Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", - "type": GQL_LIST("GQL_ReportFightNPC"), - }, - { - "name": "friendlyPlayers", - "description": "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.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "gameZone", - "description": "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.", - "type": "GQL_GameZone", - }, - { - "name": "hardModeLevel", - "description": "The hard mode level of the fight. Most fights don't support optional hard modes. This only applies to bosses like Sartharion.", - "type": GQL_Int, - }, - { - "name": "id", - "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "inProgress", - "description": "Whether or not the fight is still in progress. If this field is false, it means the entire fight has been uploaded.", - "type": GQL_Boolean, - }, - { - "name": "keystoneAffixes", - "description": "The affixes for a Mythic+ dungeon.", - "type": GQL_LIST(GQL_Int), - }, - { - "name": "keystoneBonus", - "description": "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.", - "type": GQL_Int, - }, - { - "name": "keystoneLevel", - "description": "The keystone level for a Mythic+ dungeon.", - "type": GQL_Int, - }, - { - "name": "keystoneTime", - "description": "The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.", - "type": GQL_Int, - }, - { - "name": "kill", - "description": "Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was a wipe or a failed run, etc..", - "type": GQL_Boolean, - }, - { - "name": "lastPhase", - "description": "The phase that the encounter was in when the fight ended. Counts up from 1 based off the phase type (i.e., normal phase vs intermission).", - "type": GQL_Int, - }, - { - "name": "lastPhaseAsAbsoluteIndex", - "description": "The phase that the encounter was in when the fight ended. Always increases from 0, so a fight with three real phases and two intermissions would count up from 0 to 4.", - "type": GQL_Int, - }, - { - "name": "lastPhaseIsIntermission", - "description": "Whether or not the phase that the encounter was in when the fight ended was an intermission or not.", - "type": GQL_Boolean, - }, - { - "name": "layer", - "description": "The layer of a Torghast run.", - "type": GQL_Int, - }, - { - "name": "maps", - "description": "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.", - "type": GQL_LIST("GQL_ReportMap"), - }, - { - "name": "name", - "description": "The name of the fight.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "originalEncounterID", - "description": "Some boss fights may be converted to trash fights (encounterID = 0). When this occurs, `originalEncounterID` contains the original ID of the encounter.", - "type": GQL_Int, - }, - { - "name": "phaseTransitions", - "description": "List of observed phase transitions during the fight.", - "type": GQL_LIST(GQL_NON_NULL("GQL_PhaseTransition")), - }, - { - "name": "rating", - "description": "The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.", - "type": GQL_Int, - }, - { - "name": "size", - "description": "The group size for the raid, dungeon, or arena. Null for trash.", - "type": GQL_Int, - }, - { - "name": "startTime", - "description": "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.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "talentImportCode", - "description": "The import/export code for a Retail Dragonflight talent build. Will be null for a classic or pre-Dragonflight fight.", - "type": GQL_String, - "args": [ - { - "name": "actorID", - "description": "The friendly player actor to generate talents for. Result will be null for unknown or non-player actors. Use the ReportMasterData or the friendlyPlayers field on this type to get the list of friendly player actor IDs.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - }, - { - "name": "wipeCalledTime", - "description": "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.", - "type": GQL_Float, - }, - ] - -class GQL_ReportMapBoundingBox( GQL_OBJECT ): - fields = [ - { - "name": "minX", - "description": "The smallest X position.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "maxX", - "description": "The largest X position.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "minY", - "description": "The smallest Y position.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "maxY", - "description": "The largest Y position.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_ReportDungeonPull( GQL_OBJECT ): - fields = [ - { - "name": "boundingBox", - "description": "The bounding box that encloses the positions of all players/enemies in the fight.", - "type": "GQL_ReportMapBoundingBox", - }, - { - "name": "encounterID", - "description": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "endTime", - "description": "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.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "enemyNPCs", - "description": "Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", - "type": GQL_LIST("GQL_ReportDungeonPullNPC"), - }, - { - "name": "id", - "description": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "kill", - "description": "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..", - "type": GQL_Boolean, - }, - { - "name": "maps", - "description": "All the maps that were involved in a pull.", - "type": GQL_LIST("GQL_ReportMap"), - }, - { - "name": "name", - "description": "The name of the fight.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "startTime", - "description": "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.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "x", - "description": "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.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "y", - "description": "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.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_ReportDungeonPullNPC( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "type": GQL_Int, - }, - { - "name": "gameID", - "description": "The game ID of the actor, e.g., so it can be looked up on external Web sites.", - "type": GQL_Int, - }, - { - "name": "minimumInstanceID", - "description": "The lowest instance ID seen during the pull.", - "type": GQL_Int, - }, - { - "name": "maximumInstanceID", - "description": "The highest instance ID seen during the pull.", - "type": GQL_Int, - }, - { - "name": "minimumInstanceGroupID", - "description": "The lowest instance group ID seen during the pull.", - "type": GQL_Int, - }, - { - "name": "maximumInstanceGroupID", - "description": "The highest instance group ID seen during the pull.", - "type": GQL_Int, - }, - ] - -class GQL_ReportMap( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The map's game ID.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_ReportFightNPC( GQL_OBJECT ): - fields = [ - { - "name": "gameID", - "description": "The game ID of the actor. This ID is used in events to identify sources and targets.", - "type": GQL_Int, - }, - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "type": GQL_Int, - }, - { - "name": "instanceCount", - "description": "How many instances of the NPC were seen during the fight.", - "type": GQL_Int, - }, - { - "name": "groupCount", - "description": "How many packs of the NPC were seen during the fight.", - "type": GQL_Int, - }, - { - "name": "petOwner", - "description": "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.", - "type": GQL_Int, - }, - ] - -class GQL_GameZone( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the zone.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "name", - "description": "The localized name of the zone. Will be null if no localization information exists for the zone.", - "type": GQL_String, - }, - ] - -class GQL_PhaseTransition( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The 1-indexed id of the phase. Phase IDs are absolute within a fight: phases with the same ID correspond to the same semantic phase.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "startTime", - "description": "The report-relative timestamp of the transition into the phase. The phase ends at the beginning of the next phase, or at the end of the fight.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_User( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the user.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The name of the user.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "guilds", - "description": "The list of guilds to which the user belongs. Only accessible via user authentication when you have the "view-user-profile" scope.", - "type": GQL_LIST("GQL_Guild"), - }, - { - "name": "characters", - "description": "The characters claimed by this user. Only accessible via user authentication when you have the "view-user-profile" scope.", - "type": GQL_LIST("GQL_Character"), - }, - { - "name": "battleTag", - "description": "The battle tag of the user if they have linked it.", - "type": GQL_String, - }, - ] - -class GQL_ReportMasterData( GQL_OBJECT ): - fields = [ - { - "name": "logVersion", - "description": "The version of the client parser that was used to parse and upload this log file.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "gameVersion", - "description": "The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.", - "type": GQL_Int, - }, - { - "name": "lang", - "description": "The auto-detected locale of the report. This is the source language of the original log file.", - "type": GQL_String, - }, - { - "name": "abilities", - "description": "A list of every ability that occurs in the report.", - "type": GQL_LIST("GQL_ReportAbility"), - }, - { - "name": "actors", - "description": "A list of every actor (player, NPC, pet) that occurs in the report.", - "type": GQL_LIST("GQL_ReportActor"), - "args": [ - { - "name": "type", - "description": "Optional. A filter on the actors in a report. If the type field of the actor matches the specified type field, it will be included.", - "type": GQL_String, - }, - { - "name": "subType", - "description": "Optional. A filter on the actors in a report. If the subType field of the actor matches the specified subType field, it will be included.", - "type": GQL_String, - }, - ] - }, - ] - -class GQL_ReportAbility( GQL_OBJECT ): - fields = [ - { - "name": "gameID", - "description": "The game ID of the ability.", - "type": GQL_Float, - }, - { - "name": "icon", - "description": "An icon to use for the ability.", - "type": GQL_String, - }, - { - "name": "name", - "description": "The name of the actor.", - "type": GQL_String, - }, - { - "name": "type", - "description": "The type of the ability. This represents the type of damage (e.g., the spell school in WoW).", - "type": GQL_String, - }, - ] - -class GQL_ReportActor( GQL_OBJECT ): - fields = [ - { - "name": "gameID", - "description": "The game ID of the actor.", - "type": GQL_Float, - }, - { - "name": "icon", - "description": "An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.", - "type": GQL_String, - }, - { - "name": "id", - "description": "The report ID of the actor. This ID is used in events to identify sources and targets.", - "type": GQL_Int, - }, - { - "name": "name", - "description": "The name of the actor.", - "type": GQL_String, - }, - { - "name": "petOwner", - "description": "The report ID of the actor's owner if the actor is a pet.", - "type": GQL_Int, - }, - { - "name": "server", - "description": "The normalized server name of the actor.", - "type": GQL_String, - }, - { - "name": "subType", - "description": "The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.", - "type": GQL_String, - }, - { - "name": "type", - "description": "The type of the actor, i.e., if it is a player, pet or NPC.", - "type": GQL_String, - }, - ] - -class GQL_ReportArchiveStatus( GQL_OBJECT ): - fields = [ - { - "name": "isArchived", - "description": "Whether the report has been archived.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "isAccessible", - "description": "Whether the current user can access the report. Always true if the report is not archived, and always false if not using user authentication.", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "archiveDate", - "description": "The date on which the report was archived (if it has been archived).", - "type": GQL_Int, - }, - ] - -class GQL_EncounterPhases( GQL_OBJECT ): - fields = [ - { - "name": "encounterID", - "description": "None", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "separatesWipes", - "description": "Whether the phases can be used to separate wipes in the report UI.", - "type": GQL_Boolean, - }, - { - "name": "phases", - "description": "Phase metadata for all phases in this encounter.", - "type": GQL_LIST(GQL_NON_NULL("GQL_PhaseMetadata")), - }, - ] - -class GQL_PhaseMetadata( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "Phase ID. 1-indexed", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "None", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "isIntermission", - "description": "Whether this phase represents an intermission.", - "type": GQL_Boolean, - }, - ] - -class GQL_GameData( GQL_OBJECT ): - fields = [ - { - "name": "abilities", - "description": "The player and enemy abilities for the game.", - "type": "GQL_GameAbilityPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of abilities to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "ability", - "description": "Obtain a single ability for the game.", - "type": "GQL_GameAbility", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific ability to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "achievement", - "description": "Obtain a single achievement for the game.", - "type": "GQL_GameAchievement", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific achievement to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "achievements", - "description": "Achievements for the game.", - "type": "GQL_GameAchievementPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of achievements to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "affix", - "description": "Obtain a single affix for the game.", - "type": "GQL_GameAffix", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific affix to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "affixes", - "description": "The affixes for the game.", - "type": GQL_LIST("GQL_GameAffix"), - }, - { - "name": "class", - "description": "Obtain a single class for the game.", - "type": "GQL_GameClass", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific class to retrieve by its id.", - "type": GQL_Int, - }, - { - "name": "faction_id", - "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", - "type": GQL_Int, - }, - { - "name": "zone_id", - "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", - "type": GQL_Int, - }, - ] - }, - { - "name": "classes", - "description": "Obtain the supported classes for the game.", - "type": GQL_LIST("GQL_GameClass"), - "args": [ - { - "name": "faction_id", - "description": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", - "type": GQL_Int, - }, - { - "name": "zone_id", - "description": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", - "type": GQL_Int, - }, - ] - }, - { - "name": "enchant", - "description": "Obtain a single enchant for the game.", - "type": "GQL_GameEnchant", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific enchant to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "enchants", - "description": "Enchants for the game.", - "type": "GQL_GameEnchantPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of enchants to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "factions", - "description": "Obtain all the factions that guilds and players can belong to.", - "type": GQL_LIST("GQL_GameFaction"), - }, - { - "name": "item", - "description": "Obtain a single item for the game.", - "type": "GQL_GameItem", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific item to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "item_set", - "description": "Obtain a single item set for the game.", - "type": "GQL_GameItemSet", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific item set to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "item_sets", - "description": "Item sets for the game.", - "type": "GQL_GameItemSetPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of item sets to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "items", - "description": "Items for the game.", - "type": "GQL_GameItemPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of items to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "map", - "description": "Obtain a single map for the game.", - "type": "GQL_GameMap", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific map to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "maps", - "description": "Maps for the game.", - "type": "GQL_GameMapPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of maps to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "npc", - "description": "Obtain a single NPC for the game.", - "type": "GQL_GameNPC", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific NPC to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "npcs", - "description": "NPCs for the game.", - "type": "GQL_GameNPCPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of NPCs to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - { - "name": "zone", - "description": "Obtain a single zone for the game, not to be confused with the worldData zones for ranking bosses and dungeons.", - "type": "GQL_GameZone", - "args": [ - { - "name": "id", - "description": "Required. Specify a specific game zone to retrieve by its id.", - "type": GQL_Int, - }, - ] - }, - { - "name": "zones", - "description": "Zones for the game.", - "type": "GQL_GameZonePagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of game zones to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_GameAbilityPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameAbility"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameAbility( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the ability.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "icon", - "description": "The icon for the ability.", - "type": GQL_String, - }, - { - "name": "name", - "description": "The localized name of the ability. Will be null if no localization information exists for the ability.", - "type": GQL_String, - }, - ] - -class GQL_GameAchievement( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the achievement.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "icon", - "description": "The icon for the achievement.", - "type": GQL_String, - }, - { - "name": "name", - "description": "The localized name of the achievement. Will be null if no localization information exists for the achievement.", - "type": GQL_String, - }, - ] - -class GQL_GameAchievementPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameAchievement"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameAffix( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the affix.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "icon", - "description": "The icon for the affix.", - "type": GQL_String, - }, - { - "name": "name", - "description": "The localized name of the affix. Will be null if no localization information exists for the affix.", - "type": GQL_String, - }, - ] - -class GQL_GameClass( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "An integer used to identify the class.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the class.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "slug", - "description": "A slug used to identify the class.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "specs", - "description": "The specs supported by the class.", - "type": GQL_LIST("GQL_GameSpec"), - }, - ] - -class GQL_GameSpec( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "An integer used to identify the spec.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "class", - "description": "The player class that the spec belongs to.", - "type": "GQL_GameClass", - }, - { - "name": "name", - "description": "The localized name of the class.", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "slug", - "description": "A slug used to identify the spec.", - "type": GQL_NON_NULL(GQL_String), - }, - ] - -class GQL_GameEnchant( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the enchant.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the enchant. Will be null if no localization information exists for the enchant.", - "type": GQL_String, - }, - ] - -class GQL_GameEnchantPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameEnchant"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameItem( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the item.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "icon", - "description": "The icon for the item.", - "type": GQL_String, - }, - { - "name": "name", - "description": "The localized name of the item. Will be null if no localization information exists for the item.", - "type": GQL_String, - }, - ] - -class GQL_GameItemSet( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the item set.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the item set. Will be null if no localization information exists for the item set.", - "type": GQL_String, - }, - ] - -class GQL_GameItemSetPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameItemSet"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameItemPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameItem"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameMap( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the map.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the map. Will be null if no localization information exists for the map.", - "type": GQL_String, - }, - ] - -class GQL_GameMapPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameMap"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameNPC( GQL_OBJECT ): - fields = [ - { - "name": "id", - "description": "The ID of the NPC.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "name", - "description": "The localized name of the NPC. Will be null if no localization information exists for the NPC.", - "type": GQL_String, - }, - ] - -class GQL_GameNPCPagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameNPC"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GameZonePagination( GQL_OBJECT ): - fields = [ - { - "name": "data", - "description": "List of items on the current page", - "type": GQL_LIST("GQL_GameZone"), - }, - { - "name": "total", - "description": "Number of total items selected by the query", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "per_page", - "description": "Number of items returned per page", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "current_page", - "description": "Current page of the cursor", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "from", - "description": "Number of the first item returned", - "type": GQL_Int, - }, - { - "name": "to", - "description": "Number of the last item returned", - "type": GQL_Int, - }, - { - "name": "last_page", - "description": "The last page (number of pages)", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "has_more_pages", - "description": "Determines if cursor has more pages after the current page", - "type": GQL_NON_NULL(GQL_Boolean), - }, - ] - -class GQL_GuildData( GQL_OBJECT ): - fields = [ - { - "name": "guild", - "description": "Obtain a specific guild either by id or by name/serverSlug/serverRegion.", - "type": "GQL_Guild", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single guild to retrieve.", - "type": GQL_Int, - }, - { - "name": "name", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - ] - }, - { - "name": "guilds", - "description": "The set of all guilds supported by the site. Can be optionally filtered to a specific server id.", - "type": "GQL_GuildPagination", - "args": [ - { - "name": "limit", - "description": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - { - "name": "serverID", - "description": "Optional. The ID of a specific server. If present, only guilds from that server (and any connected servers) will be fetched.", - "type": GQL_Int, - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Must be used in conjunction with serverRegion to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", - "type": GQL_String, - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific server. Must be used in conjunction with serverSlug to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", - "type": GQL_String, - }, - ] - }, - ] - -class GQL_ProgressRaceData( GQL_OBJECT ): - fields = [ - { - "name": "progressRace", - "description": "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.", - "type": GQL_JSON, - "args": [ - { - "name": "serverRegion", - "description": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", - "type": GQL_String, - }, - { - "name": "serverSubregion", - "description": "Optional. The short name of a subregion to filter to. Must be paired with serverRegion. Rankings for that specific subregion will be fetched.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", - "type": GQL_String, - }, - { - "name": "zoneID", - "description": "Optional. If not specified, the latest zone will be used.", - "type": GQL_Int, - }, - { - "name": "competitionID", - "description": "Optional. If not specified, the race to world first competition will be used.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. If not specified, the highest difficulty will be used.", - "type": GQL_Int, - }, - { - "name": "size", - "description": "Optional. If not specified, the default size for the highest difficulty will be used.", - "type": GQL_Int, - }, - { - "name": "guildID", - "description": "Optional. The ID of a single guild to retrieve.", - "type": GQL_Int, - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - ] - }, - { - "name": "detailedComposition", - "description": "Detailed composition data for a given guild and encounter.", - "type": GQL_JSON, - "args": [ - { - "name": "competitionID", - "description": "Optional. If not specified, the race to world first competition will be used.", - "type": GQL_Int, - }, - { - "name": "guildID", - "description": "Optional. The ID of a single guild to retrieve.", - "type": GQL_Int, - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "serverSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "serverRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "encounterID", - "description": "Optional. If not specified, the current boss that is being pulled will be used.", - "type": GQL_Int, - }, - { - "name": "difficulty", - "description": "Optional. If not specified, the highest difficulty will be used.", - "type": GQL_Int, - }, - { - "name": "size", - "description": "Optional. If not specified, the default size for the highest difficulty will be used.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_RateLimitData( GQL_OBJECT ): - fields = [ - { - "name": "limitPerHour", - "description": "The total amount of points this API key can spend per hour.", - "type": GQL_NON_NULL(GQL_Int), - }, - { - "name": "pointsSpentThisHour", - "description": "The total amount of points spent during this hour.", - "type": GQL_NON_NULL(GQL_Float), - }, - { - "name": "pointsResetIn", - "description": "The number of seconds remaining until the points reset.", - "type": GQL_NON_NULL(GQL_Int), - }, - ] - -class GQL_ReportData( GQL_OBJECT ): - fields = [ - { - "name": "report", - "description": "Obtain a specific report by its code.", - "type": "GQL_Report", - "args": [ - { - "name": "code", - "description": "Required. The code of a single report to retrieve.", - "type": GQL_String, - }, - ] - }, - { - "name": "reports", - "description": "A set of reports for a specific guild, guild tag, or user.", - "type": "GQL_ReportPagination", - "args": [ - { - "name": "endTime", - "description": "Optional. A UNIX timestamp with millisecond precision representing the end time for a report range. If omitted, defaults to the current time in milliseconds.", - "type": GQL_Float, - }, - { - "name": "guildID", - "description": "Optional. The ID of a specific guild. Reports from that guild will be fetched.", - "type": GQL_Int, - }, - { - "name": "guildName", - "description": "Optional. The name of a specific guild. Must be used in conjunction with guildServerSlug and guildServerRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "guildServerSlug", - "description": "Optional. The name of a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "guildServerRegion", - "description": "Optional. The region for a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", - "type": GQL_String, - }, - { - "name": "guildTagID", - "description": "Optional. The ID of a specific guild tag. Reports from that guild tag will be fetched. This will take precedence over all other guild arguments.", - "type": GQL_Int, - }, - { - "name": "userID", - "description": "Optional. The ID of a specific user. Reports from that user's personal logs will be fetched.", - "type": GQL_Int, - }, - { - "name": "limit", - "description": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", - "type": GQL_Int, - }, - { - "name": "page", - "description": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", - "type": GQL_Int, - }, - { - "name": "startTime", - "description": "Optional. A UNIX timestamp with millisecond precision representing a start time for a report range. If omitted, defaults to 0.", - "type": GQL_Float, - }, - { - "name": "zoneID", - "description": "Optional. The ID of a specific zone to filter to. Reports with that zone as their default will be included.", - "type": GQL_Int, - }, - { - "name": "gameZoneID", - "description": "Optional. The ID of a specific game zone to filter reports to.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL_UserData( GQL_OBJECT ): - fields = [ - { - "name": "user", - "description": "Obtain a specific user by id.", - "type": "GQL_User", - "args": [ - { - "name": "id", - "description": "Required. Specify a single user ID to retrieve.", - "type": GQL_Int, - }, - ] - }, - { - "name": "currentUser", - "description": "Obtain the current user (only works with user endpoint).", - "type": "GQL_User", - }, - ] - -class GQL_WorldData( GQL_OBJECT ): - fields = [ - { - "name": "encounter", - "description": "Obtain a specific encounter by id.", - "type": "GQL_Encounter", - "args": [ - { - "name": "id", - "description": "Required. Specify a single encounter ID to retrieve.", - "type": GQL_Int, - }, - ] - }, - { - "name": "expansion", - "description": "A single expansion obtained by ID.", - "type": "GQL_Expansion", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single expansion to retrieve.", - "type": GQL_Int, - }, - ] - }, - { - "name": "expansions", - "description": "The set of all expansions supported by the site.", - "type": GQL_LIST("GQL_Expansion"), - }, - { - "name": "region", - "description": "Obtain a specific region by its ID.", - "type": "GQL_Region", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single region to retrieve.", - "type": GQL_Int, - }, - ] - }, - { - "name": "regions", - "description": "The set of all regions supported by the site.", - "type": GQL_LIST("GQL_Region"), - }, - { - "name": "server", - "description": "Obtain a specific server either by id or by slug and region.", - "type": "GQL_Server", - "args": [ - { - "name": "id", - "description": "Optional. The ID of a single server to retrieve.", - "type": GQL_Int, - }, - { - "name": "region", - "description": "Optional. The compact English abbreviation for a specific region (e.g., "US"). Use in conjunction with the server slug to retrieve a single server.", - "type": GQL_String, - }, - { - "name": "slug", - "description": "Optional. A server slug. Use in conjunction with the server region to retrieve a single server.", - "type": GQL_String, - }, - ] - }, - { - "name": "subregion", - "description": "Obtain a specific subregion by its ID.", - "type": "GQL_Subregion", - "args": [ - { - "name": "id", - "description": "Required. The ID of a single subregion to retrieve.", - "type": GQL_Int, - }, - ] - }, - { - "name": "zone", - "description": "Obtain a specific zone by its ID.", - "type": "GQL_Zone", - "args": [ - { - "name": "id", - "description": "Required. The ID of a specific zone.", - "type": GQL_Int, - }, - ] - }, - { - "name": "zones", - "description": "Obtain a set of all zones supported by the site.", - "type": GQL_LIST("GQL_Zone"), - "args": [ - { - "name": "expansion_id", - "description": "Optional. The ID of a specific expansion. If omitted, the zones from all expansions will be retrieved.", - "type": GQL_Int, - }, - ] - }, - ] - -class GQL___Schema( GQL_OBJECT ): - fields = [ - { - "name": "types", - "description": "A list of all types supported by this server.", - "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___Type"))), - }, - { - "name": "queryType", - "description": "The type that query operations will be rooted at.", - "type": GQL_NON_NULL("GQL___Type"), - }, - { - "name": "mutationType", - "description": "If this server supports mutation, the type that mutation operations will be rooted at.", - "type": "GQL___Type", - }, - { - "name": "subscriptionType", - "description": "If this server support subscription, the type that subscription operations will be rooted at.", - "type": "GQL___Type", - }, - { - "name": "directives", - "description": "A list of all directives supported by this server.", - "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___Directive"))), - }, - ] - -class GQL___Type( GQL_OBJECT ): - fields = [ - { - "name": "kind", - "description": "None", - "type": GQL_NON_NULL(GQL___TypeKind), - }, - { - "name": "name", - "description": "None", - "type": GQL_String, - }, - { - "name": "description", - "description": "None", - "type": GQL_String, - }, - { - "name": "fields", - "description": "None", - "type": GQL_LIST(GQL_NON_NULL("GQL___Field")), - "args": [ - { - "name": "includeDeprecated", - "description": "None", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "interfaces", - "description": "None", - "type": GQL_LIST(GQL_NON_NULL("GQL___Type")), - }, - { - "name": "possibleTypes", - "description": "None", - "type": GQL_LIST(GQL_NON_NULL("GQL___Type")), - }, - { - "name": "enumValues", - "description": "None", - "type": GQL_LIST(GQL_NON_NULL("GQL___EnumValue")), - "args": [ - { - "name": "includeDeprecated", - "description": "None", - "type": GQL_Boolean, - }, - ] - }, - { - "name": "inputFields", - "description": "None", - "type": GQL_LIST(GQL_NON_NULL("GQL___InputValue")), - }, - { - "name": "ofType", - "description": "None", - "type": "GQL___Type", - }, - ] - -class GQL___Field( GQL_OBJECT ): - fields = [ - { - "name": "name", - "description": "None", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "description", - "description": "None", - "type": GQL_String, - }, - { - "name": "args", - "description": "None", - "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___InputValue"))), - }, - { - "name": "type", - "description": "None", - "type": GQL_NON_NULL("GQL___Type"), - }, - { - "name": "isDeprecated", - "description": "None", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "deprecationReason", - "description": "None", - "type": GQL_String, - }, - ] - -class GQL___InputValue( GQL_OBJECT ): - fields = [ - { - "name": "name", - "description": "None", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "description", - "description": "None", - "type": GQL_String, - }, - { - "name": "type", - "description": "None", - "type": GQL_NON_NULL("GQL___Type"), - }, - { - "name": "defaultValue", - "description": "A GraphQL-formatted string representing the default value for this input value.", - "type": GQL_String, - }, - ] - -class GQL___EnumValue( GQL_OBJECT ): - fields = [ - { - "name": "name", - "description": "None", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "description", - "description": "None", - "type": GQL_String, - }, - { - "name": "isDeprecated", - "description": "None", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "deprecationReason", - "description": "None", - "type": GQL_String, - }, - ] - -class GQL___Directive( GQL_OBJECT ): - fields = [ - { - "name": "name", - "description": "None", - "type": GQL_NON_NULL(GQL_String), - }, - { - "name": "description", - "description": "None", - "type": GQL_String, - }, - { - "name": "args", - "description": "None", - "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL("GQL___InputValue"))), - }, - { - "name": "isRepeatable", - "description": "None", - "type": GQL_NON_NULL(GQL_Boolean), - }, - { - "name": "locations", - "description": "None", - "type": GQL_NON_NULL(GQL_LIST(GQL_NON_NULL(GQL___DirectiveLocation))), - }, - ] - -class GQL_ArchonViewModels( GQL_OBJECT ): - fields = [ - { - "name": "googleAnalytics", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "game", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "translations", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "keys", - "description": "None", - "type": GQL_LIST(GQL_String), - }, - ] - }, - { - "name": "header", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "gameSlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "headerTitle", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "footer", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "indexPage", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "gamePage", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "contactPage", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "aboutPage", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "announcementPage", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "gameSlugs", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "buildsZonePageSlugs", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "buildsZonePage", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "gameSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "rankingsSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "zoneTypeSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "difficultySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "encounterSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "affixesSlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "buildsSpecPageSlugs", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "buildsSpecPage", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "gameSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "classSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "specSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "zoneTypeSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "categorySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "difficultySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "encounterSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "affixesSlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "buildsClassesAndSpecsPage", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "gameSlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "ability", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "id", - "description": "None", - "type": GQL_Int, - }, - ] - }, - { - "name": "articleCategory", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "articleCategorySlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "articleCategories", - "description": "None", - "type": GQL_JSON, - }, - { - "name": "articleSlugs", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "articleCategorySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "siteName", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "article", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "articleSlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "articleCategorySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "siteName", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "cmsNavigation", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "currentSlug", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "pageOfArticlePreviews", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "articleCategorySlug", - "description": "None", - "type": GQL_String, - }, - { - "name": "pageNumber", - "description": "None", - "type": GQL_Int, - }, - { - "name": "siteName", - "description": "None", - "type": GQL_String, - }, - ] - }, - { - "name": "snippets", - "description": "None", - "type": GQL_JSON, - "args": [ - { - "name": "snippetSlugs", - "description": "None", - "type": GQL_LIST(GQL_String), - }, - ] - }, - { - "name": "articleIndexPage", - "description": "None", - "type": GQL_JSON, - }, - ] \ No newline at end of file diff --git a/wcl/types/objects.py b/wcl/types/objects.py new file mode 100644 index 0000000..66c206b --- /dev/null +++ b/wcl/types/objects.py @@ -0,0 +1,4402 @@ +from .primitives import * +from .enums import * +from .scalars import * + +""" +OBJECT TYPES +THIS FILE IS GENERATED BY `wcl/__main__.py`. +""" + +class GQL_Query( GQL_OBJECT ): + fields = [ + { + "name": "characterData", + "descrption": "Obtain the character data object that allows the retrieval of individual characters or filtered collections of characters.", + "type": ["GQL_CharacterData"], + }, + { + "name": "gameData", + "descrption": "Obtain the game data object that holds collections of static data such as abilities, achievements, classes, items, NPCs, etc..", + "type": ["GQL_GameData"], + }, + { + "name": "guildData", + "descrption": "Obtain the guild data object that allows the retrieval of individual guilds or filtered collections of guilds.", + "type": ["GQL_GuildData"], + }, + { + "name": "progressRaceData", + "descrption": "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.", + "type": ["GQL_ProgressRaceData"], + }, + { + "name": "rateLimitData", + "descrption": "Obtain the rate limit data object to see how many points have been spent by this key.", + "type": ["GQL_RateLimitData"], + }, + { + "name": "reportData", + "descrption": "Obtain the report data object that allows the retrieval of individual reports or filtered collections of reports by guild or by user.", + "type": ["GQL_ReportData"], + }, + { + "name": "userData", + "descrption": "Obtain the user object that allows the retrieval of the authorized user's id and username.", + "type": ["GQL_UserData"], + }, + { + "name": "worldData", + "descrption": "Obtain the world data object that holds collections of data such as all expansions, regions, subregions, servers, dungeon/raid zones, and encounters.", + "type": ["GQL_WorldData"], + }, + ] + +class GQL_CharacterData( GQL_OBJECT ): + """ + The CharacterData object enables the retrieval of single characters or filtered collections of characters. + """ + fields = [ + { + "name": "character", + "descrption": "Obtain a specific character either by id or by name/server_slug/server_region.", + "type": ["GQL_Character"], + "args": [ + { + "name": "id", + "descrption": "Optional. The ID of a single character to retrieve.", + "type": ["GQL_Int"], + }, + { + "name": "name", + "descrption": "Optional. The name of a specific character. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a character.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The slug of a specific server. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": ["GQL_String"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The region for a specific character. Must be used in conjunction with name and serverRegion to uniquely identify a character.", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "characters", + "descrption": "A collection of characters for a specific guild.", + "type": ["GQL_CharacterPagination"], + "args": [ + { + "name": "guildID", + "descrption": "Required. The ID of a specific guild. Characters from that guild will be fetched.", + "type": ["GQL_Int"], + }, + { + "name": "limit", + "descrption": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_Character( GQL_OBJECT ): + """ + A player character. Characters can earn individual rankings and appear in reports. + """ + fields = [ + { + "name": "canonicalID", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "claimed", + "descrption": "Whether this character is claimed by the current user. Only accessible if accessed via the user API with the 'view-user-profile' scope.", + "type": ["GQL_Boolean"], + }, + { + "name": "classID", + "descrption": "The class id of the character.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "encounterRankings", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "byBracket", + "descrption": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": ["GQL_Boolean"], + }, + { + "name": "className", + "descrption": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": ["GQL_String"], + }, + { + "name": "compare", + "descrption": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": ["GQL_RankingCompareType"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Required. The specific encounter whose rankings should be fetched.", + "type": ["GQL_Int"], + }, + { + "name": "includeCombatantInfo", + "descrption": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": ["GQL_Boolean"], + }, + { + "name": "includePrivateLogs", + "descrption": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": ["GQL_Boolean"], + }, + { + "name": "metric", + "descrption": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": ["GQL_CharacterRankingMetricType"], + }, + { + "name": "partition", + "descrption": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": ["GQL_Int"], + }, + { + "name": "role", + "descrption": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": ["GQL_RoleType"], + }, + { + "name": "size", + "descrption": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": ["GQL_Int"], + }, + { + "name": "specName", + "descrption": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": ["GQL_String"], + }, + { + "name": "timeframe", + "descrption": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": ["GQL_RankingTimeframeType"], + }, + ] + }, + { + "name": "faction", + "descrption": "The faction of the character.", + "type": ["GQL_NON_NULL","GQL_GameFaction"], + }, + { + "name": "gameData", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "specID", + "descrption": "Optional. A specific spec ID to retrieve information for. If omitted, the last observed spec on Armory (WoW) or Lodestone (FF) will be used.", + "type": ["GQL_Int"], + }, + { + "name": "forceUpdate", + "descrption": "Optional. Whether or not to force the updating of the character before returning the game data.", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "guildRank", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "guilds", + "descrption": "All guilds that the character belongs to.", + "type": ["GQL_LIST","GQL_Guild"], + }, + { + "name": "hidden", + "descrption": "Whether or not the character has all its rankings hidden.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "id", + "descrption": "The ID of the character.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "level", + "descrption": "The level of the character.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The name of the character.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "recentReports", + "descrption": "Recent reports for the character.", + "type": ["GQL_ReportPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of recent reports to retrieve. If omitted, defaults to 10. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "server", + "descrption": "The server that the character belongs to.", + "type": ["GQL_NON_NULL","GQL_Server"], + }, + { + "name": "zoneRankings", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "byBracket", + "descrption": "Optional. Whether or not to use bracket rankings instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": ["GQL_Boolean"], + }, + { + "name": "className", + "descrption": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. Only used by games that support multiple classes on a single character..", + "type": ["GQL_String"], + }, + { + "name": "compare", + "descrption": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": ["GQL_RankingCompareType"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the rankings to a specific difficulty. If omitted, the highest difficulty is used.", + "type": ["GQL_Int"], + }, + { + "name": "includePrivateLogs", + "descrption": "Optional. Whether or not to include private logs in the results. This option is only available if using the user GraphQL endpoint.", + "type": ["GQL_Boolean"], + }, + { + "name": "metric", + "descrption": "Optional. You can filter to a specific character metric like dps or hps. If omitted, an appropriate default metric for the zone will be chosen.", + "type": ["GQL_CharacterRankingMetricType"], + }, + { + "name": "partition", + "descrption": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen. A special value of -1 can be passed to fetch data from all partitions.", + "type": ["GQL_Int"], + }, + { + "name": "role", + "descrption": "Optional. The slug for a specific role. This allow you to only fetch ranks for the healing role, dps role or tank role.", + "type": ["GQL_RoleType"], + }, + { + "name": "size", + "descrption": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": ["GQL_Int"], + }, + { + "name": "specName", + "descrption": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": ["GQL_String"], + }, + { + "name": "timeframe", + "descrption": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": ["GQL_RankingTimeframeType"], + }, + { + "name": "zoneID", + "descrption": "Optional. If not specified, the latest unfrozen zone will be used.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_GameFaction( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "id", + "descrption": "An integer representing the faction id.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the faction.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + ] + +class GQL_Guild( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "attendance", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_GuildAttendancePagination"], + "args": [ + { + "name": "guildTagID", + "descrption": "Optional. Whether or not to filter the attendance to a specific guild tag.", + "type": ["GQL_Int"], + }, + { + "name": "limit", + "descrption": "Optional. The number of reports to retrieve per page. If omitted, defaults to 16. The maximum allowed value is 25, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + { + "name": "zoneID", + "descrption": "Optional. Whether or not to filter the attendance table to a specific zone.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "competitionMode", + "descrption": "Whether or not the guild has competition mode enabled.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "description", + "descrption": "The description for the guild that is displayed with the guild name on the site.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "faction", + "descrption": "The faction of the guild.", + "type": ["GQL_NON_NULL","GQL_GameFaction"], + }, + { + "name": "id", + "descrption": "The ID of the guild.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The name of the guild.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "server", + "descrption": "The server that the guild belongs to.", + "type": ["GQL_NON_NULL","GQL_Server"], + }, + { + "name": "stealthMode", + "descrption": "Whether or not the guild has stealth mode enabled.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "tags", + "descrption": "The tags used to label reports. In the site UI, these are called raid teams.", + "type": ["GQL_LIST","GQL_GuildTag"], + }, + { + "name": "members", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_CharacterPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "currentUserRank", + "descrption": "The current user's rank within the guild. Only accessible via user authentication with the 'view-user-profile' scope.", + "type": ["GQL_GuildRank"], + }, + { + "name": "zoneRanking", + "descrption": "The guild's ranking for a zone. If `zoneId` is unset or null, uses the latest zone.", + "type": ["GQL_NON_NULL","GQL_GuildZoneRankings"], + "args": [ + { + "name": "zoneId", + "descrption": "", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_GuildAttendancePagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GuildAttendance"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GuildAttendance( GQL_OBJECT ): + """ + Attendance for a specific report within a guild. + """ + fields = [ + { + "name": "code", + "descrption": "The code of the report for the raid night.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "players", + "descrption": "The players that attended that raid night.", + "type": ["GQL_LIST","GQL_PlayerAttendance"], + }, + { + "name": "startTime", + "descrption": "The start time of the raid night.", + "type": ["GQL_Float"], + }, + { + "name": "zone", + "descrption": "The principal zone of the raid night.", + "type": ["GQL_Zone"], + }, + ] + +class GQL_PlayerAttendance( GQL_OBJECT ): + """ + Attendance for a specific player on a specific raid night. + """ + fields = [ + { + "name": "name", + "descrption": "The name of the player.", + "type": ["GQL_String"], + }, + { + "name": "type", + "descrption": "The class of the player.", + "type": ["GQL_String"], + }, + { + "name": "presence", + "descrption": "Presence info for the player. A value of 1 means the player was present. A value of 2 indicates present but on the bench.", + "type": ["GQL_Int"], + }, + ] + +class GQL_Zone( GQL_OBJECT ): + """ + A single zone from an expansion that represents a raid, dungeon, arena, etc. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the zone.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "brackets", + "descrption": "The bracket information for this zone. This field will be null if the zone does not support brackets.", + "type": ["GQL_Bracket"], + }, + { + "name": "difficulties", + "descrption": "A list of all the difficulties supported for this zone.", + "type": ["GQL_LIST","GQL_Difficulty"], + }, + { + "name": "encounters", + "descrption": "The encounters found within this zone.", + "type": ["GQL_LIST","GQL_Encounter"], + }, + { + "name": "expansion", + "descrption": "The expansion that this zone belongs to.", + "type": ["GQL_NON_NULL","GQL_Expansion"], + }, + { + "name": "frozen", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "name", + "descrption": "The name of the zone.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "partitions", + "descrption": "A list of all the partitions supported for this zone.", + "type": ["GQL_LIST","GQL_Partition"], + }, + ] + +class GQL_Bracket( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "min", + "descrption": "An integer representing the minimum value used by bracket number 1, etc.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "max", + "descrption": "An integer representing the value used by bracket N when there are a total of N brackets, etc.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "bucket", + "descrption": "A float representing the value to increment when moving from bracket 1 to bracket N, etc.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "type", + "descrption": "The localized name of the bracket type.", + "type": ["GQL_String"], + }, + ] + +class GQL_Difficulty( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "id", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name for the difficulty level.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "sizes", + "descrption": "A list of supported sizes for the difficulty level. An empty result means that the difficulty level has a flexible raid size.", + "type": ["GQL_LIST","GQL_Int"], + }, + ] + +class GQL_Encounter( GQL_OBJECT ): + """ + A single encounter for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the encounter.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the encounter.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "characterRankings", + "descrption": "Player rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "bracket", + "descrption": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": ["GQL_Int"], + }, + { + "name": "filter", + "descrption": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": ["GQL_String"], + }, + { + "name": "page", + "descrption": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": ["GQL_Int"], + }, + { + "name": "partition", + "descrption": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": ["GQL_Int"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": ["GQL_String"], + }, + { + "name": "size", + "descrption": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": ["GQL_Int"], + }, + { + "name": "leaderboard", + "descrption": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": ["GQL_LeaderboardRank"], + }, + { + "name": "hardModeLevel", + "descrption": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": ["GQL_HardModeLevelRankFilter"], + }, + { + "name": "metric", + "descrption": "Optional. You can filter to a specific player metric like dps or hps. If omitted, an appropriate default player metric for the zone will be chosen.", + "type": ["GQL_CharacterRankingMetricType"], + }, + { + "name": "includeCombatantInfo", + "descrption": "Optional. Whether or not to include detailed combatant info such as gear in the results.", + "type": ["GQL_Boolean"], + }, + { + "name": "className", + "descrption": "Optional. The slug for a specific class. Whether or not to filter rankings to a specific class. If omitted, data for all classes will be used.", + "type": ["GQL_String"], + }, + { + "name": "specName", + "descrption": "Optional. The slug for a specific spec. Whether or not to filter rankings to a specific spec. If omitted, data for all specs will be used.", + "type": ["GQL_String"], + }, + { + "name": "externalBuffs", + "descrption": "Optional. Controls whether to include ranks with/without external buffs. Most games and zones do not support this filter and will quietly ignore it.", + "type": ["GQL_ExternalBuffRankFilter"], + }, + { + "name": "covenantID", + "descrption": "Optional. The covenant ID to filter to if viewing Shadowlands rankings.", + "type": ["GQL_Int"], + }, + { + "name": "soulbindID", + "descrption": "Optional. The soulbind ID to filter to if viewing Shadowlands rankings.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "fightRankings", + "descrption": "Fight rankings information for a zone. This data is not considered frozen, and it can change without notice. Use at your own risk.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "bracket", + "descrption": "Optional. A specific bracket (e.g., item level range) to use instead of overall rankings. For WoW, brackets are item levels or keystones. For FF, brackets are patches.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. A specific difficulty to fetch rankings for. If omitted, the highest difficulty is used.", + "type": ["GQL_Int"], + }, + { + "name": "filter", + "descrption": "Optional. A filter string for advanced searching. The syntax matches the one used on the web site exactly, so you can filter encounter rankings on the site to figure out the string to use.", + "type": ["GQL_String"], + }, + { + "name": "page", + "descrption": "Optional. Which page of rankings to fetch. By default the first page is used.", + "type": ["GQL_Int"], + }, + { + "name": "partition", + "descrption": "Optional. Whether or not to filter the rankings to a specific partition. By default, the latest partition is chosen.", + "type": ["GQL_Int"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": ["GQL_String"], + }, + { + "name": "size", + "descrption": "Optional. Whether or not to filter rankings to a specific size. If omitted, the first valid raid size will be used.", + "type": ["GQL_Int"], + }, + { + "name": "leaderboard", + "descrption": "Optional. Controls whether to include ranks without backing logs in games & content types that support this. Ignored if unsupported.", + "type": ["GQL_LeaderboardRank"], + }, + { + "name": "hardModeLevel", + "descrption": "Optional. Filters ranks to a specific hard mode (0-5) or any hard mode level (-1). Most encounters do not have variable hard mode levels. Use `difficulty` for ESO Veteran Hard Modes.", + "type": ["GQL_HardModeLevelRankFilter"], + }, + { + "name": "metric", + "descrption": "Optional. You can filter to a specific fight metric like speed or execution. If omitted, an appropriate default fight metric for the zone will be chosen.", + "type": ["GQL_FightRankingMetricType"], + }, + ] + }, + { + "name": "zone", + "descrption": "The zone that this encounter is found in.", + "type": ["GQL_NON_NULL","GQL_Zone"], + }, + { + "name": "journalID", + "descrption": "The Blizzard journal ID, used as the identifier in the encounter journal and various Blizzard APIs like progression.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_Expansion( GQL_OBJECT ): + """ + A single expansion for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the expansion.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the expansion.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "zones", + "descrption": "The zones (e.g., raids and dungeons) supported for this expansion.", + "type": ["GQL_LIST","GQL_Zone"], + }, + ] + +class GQL_Partition( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "id", + "descrption": "An integer representing a specific partition within a zone.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name for partition.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "compactName", + "descrption": "The compact localized name for the partition. Typically an abbreviation to conserve space.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "default", + "descrption": "Whether or not the partition is the current default when viewing rankings or statistics for the zone.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_Server( GQL_OBJECT ): + """ + A single server. Servers correspond to actual game servers that characters and guilds reside on. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the server.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The name of the server in the locale of the subregion that the server belongs to.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "normalizedName", + "descrption": "The normalized name is a transformation of the name, dropping spaces. It is how the server appears in a World of Warcraft log file.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "slug", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "region", + "descrption": "The region that this server belongs to.", + "type": ["GQL_NON_NULL","GQL_Region"], + }, + { + "name": "subregion", + "descrption": "The subregion that this server belongs to.", + "type": ["GQL_NON_NULL","GQL_Subregion"], + }, + { + "name": "guilds", + "descrption": "The guilds found on this server (and any servers connected to this one.", + "type": ["GQL_GuildPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of guilds to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "characters", + "descrption": "The characters found on this server (and any servers connected to this one.", + "type": ["GQL_CharacterPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of characters to retrieve per page. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_Region( GQL_OBJECT ): + """ + A single region for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the region.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "compactName", + "descrption": "The localized compact name of the region, e.g., US for United States.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "name", + "descrption": "The localized name of the region.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "slug", + "descrption": "The slug for the region, usable when looking up characters and guilds by server.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "subregions", + "descrption": "The subregions found within this region.", + "type": ["GQL_LIST","GQL_Subregion"], + }, + { + "name": "servers", + "descrption": "The servers found within this region.", + "type": ["GQL_ServerPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_Subregion( GQL_OBJECT ): + """ + A single subregion. Subregions are used to divide a region into sub-categories, such as French or German subregions of a Europe region. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the subregion.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the subregion.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "region", + "descrption": "The region that this subregion is found in.", + "type": ["GQL_NON_NULL","GQL_Region"], + }, + { + "name": "servers", + "descrption": "The servers found within this region.", + "type": ["GQL_ServerPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of servers to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_ServerPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_Server"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GuildPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_Guild"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_CharacterPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_Character"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GuildTag( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the tag.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "guild", + "descrption": "The guild that the tag belongs to.", + "type": ["GQL_NON_NULL","GQL_Guild"], + }, + { + "name": "name", + "descrption": "The name of the tag.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + ] + +class GQL_GuildZoneRankings( GQL_OBJECT ): + """ + A guild's rankings within a zone. + """ + fields = [ + { + "name": "progress", + "descrption": "The progress ranks for the guild. Always uses the highest difficulty.", + "type": ["GQL_WorldRegionServerRankPositions"], + "args": [ + { + "name": "size", + "descrption": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "speed", + "descrption": "The all-star based speed rank for the guild.", + "type": ["GQL_WorldRegionServerRankPositions"], + "args": [ + { + "name": "size", + "descrption": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Raid difficulty.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "completeRaidSpeed", + "descrption": "The complete raid speed ranks for the guild. Most non-Classic WoW zones do not support complete raid ranks.", + "type": ["GQL_WorldRegionServerRankPositions"], + "args": [ + { + "name": "size", + "descrption": "Raid size. Only used for Classic WoW and certain old Retail WoW zones.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Raid difficulty.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_WorldRegionServerRankPositions( GQL_OBJECT ): + """ + A collection containing some combination of world, region, and server ranks. + """ + fields = [ + { + "name": "worldRank", + "descrption": "", + "type": ["GQL_Rank"], + }, + { + "name": "regionRank", + "descrption": "", + "type": ["GQL_Rank"], + }, + { + "name": "serverRank", + "descrption": "", + "type": ["GQL_Rank"], + }, + ] + +class GQL_Rank( GQL_OBJECT ): + fields = [ + { + "name": "number", + "descrption": "The ordinal rank (usually written 'Rank N'). Rank 1 = highest.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "percentile", + "descrption": "The percentile of the rank as an integer in [0, 100]. Always null for guild ranks.", + "type": ["GQL_Int"], + }, + { + "name": "color", + "descrption": "The color class used by the site for this rank.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + ] + +class GQL_ReportPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_Report"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_Report( GQL_OBJECT ): + """ + A single report uploaded by a player to a guild or personal logs. + """ + fields = [ + { + "name": "code", + "descrption": "The report code, a unique value used to identify the report.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "endTime", + "descrption": "The end time of the report. This is a UNIX timestamp representing the timestamp of the last event contained in the report.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "events", + "descrption": "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.", + "type": ["GQL_ReportEventPaginator"], + "args": [ + { + "name": "abilityID", + "descrption": "Optional. The game id of a specific ability to filter to.", + "type": ["GQL_Float"], + }, + { + "name": "dataType", + "descrption": "Optional. You can filter to a specific subset of events.", + "type": ["GQL_EventDataType"], + }, + { + "name": "death", + "descrption": "Optional. If viewing death events, a specific death to obtain information for.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "endTime", + "descrption": "Optional. The end time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "filterExpression", + "descrption": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": ["GQL_String"], + }, + { + "name": "hostilityType", + "descrption": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": ["GQL_HostilityType"], + }, + { + "name": "includeResources", + "descrption": "Optional. Whether or not to include detailed unit resources for actors. Adds substantially to bandwidth, so defaults to off.", + "type": ["GQL_Boolean"], + }, + { + "name": "killType", + "descrption": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": ["GQL_KillType"], + }, + { + "name": "limit", + "descrption": "Optional. How many events to retrieve. Allowed value ranges are 100-10000. The default value is 300.", + "type": ["GQL_Int"], + }, + { + "name": "sourceAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceClass", + "descrption": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "sourceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": ["GQL_Int"], + }, + { + "name": "sourceInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "startTime", + "descrption": "Optional. The start time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "targetAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetClass", + "descrption": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "targetID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": ["GQL_Int"], + }, + { + "name": "targetInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "translate", + "descrption": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if is a priority, and you do not care about the names.", + "type": ["GQL_Boolean"], + }, + { + "name": "useAbilityIDs", + "descrption": "Optional. Whether or not to include detailed ability information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": ["GQL_Boolean"], + }, + { + "name": "useActorIDs", + "descrption": "Optional. Whether or not to include detailed actor information. Adds substantially to bandwidth, so defaults to true. Set to false if you do not want to fetch the master data of the report.", + "type": ["GQL_Boolean"], + }, + { + "name": "viewOptions", + "descrption": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": ["GQL_Int"], + }, + { + "name": "wipeCutoff", + "descrption": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "exportedSegments", + "descrption": "The number of exported segments in the report. This is how many segments have been processed for rankings.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "fights", + "descrption": "A set of fights with details about participating players.", + "type": ["GQL_LIST","GQL_ReportFight"], + "args": [ + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "killType", + "descrption": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": ["GQL_KillType"], + }, + { + "name": "translate", + "descrption": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "graph", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "abilityID", + "descrption": "Optional. The game id of a specific ability to filter to.", + "type": ["GQL_Float"], + }, + { + "name": "dataType", + "descrption": "Optional. You can filter to a specific subset of events.", + "type": ["GQL_GraphDataType"], + }, + { + "name": "death", + "descrption": "Optional. If viewing death events, a specific death to obtain information for.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "endTime", + "descrption": "Optional. The end time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "filterExpression", + "descrption": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": ["GQL_String"], + }, + { + "name": "hostilityType", + "descrption": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": ["GQL_HostilityType"], + }, + { + "name": "killType", + "descrption": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": ["GQL_KillType"], + }, + { + "name": "sourceAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceClass", + "descrption": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "sourceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": ["GQL_Int"], + }, + { + "name": "sourceInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "startTime", + "descrption": "Optional. The start time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "targetAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetClass", + "descrption": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "targetID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": ["GQL_Int"], + }, + { + "name": "targetInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "translate", + "descrption": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": ["GQL_Boolean"], + }, + { + "name": "viewOptions", + "descrption": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": ["GQL_Int"], + }, + { + "name": "viewBy", + "descrption": "Optional. Whether to view by source, by target or by ability.", + "type": ["GQL_ViewType"], + }, + { + "name": "wipeCutoff", + "descrption": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "guild", + "descrption": "The guild that the report belongs to. If this is null, then the report was uploaded to the user's personal logs.", + "type": ["GQL_Guild"], + }, + { + "name": "guildTag", + "descrption": "The guild tag that the report belongs to. If this is null, then the report was not tagged.", + "type": ["GQL_GuildTag"], + }, + { + "name": "owner", + "descrption": "The user that uploaded the report.", + "type": ["GQL_User"], + }, + { + "name": "masterData", + "descrption": "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.", + "type": ["GQL_ReportMasterData"], + "args": [ + { + "name": "translate", + "descrption": "Optional. Whether or not the actors and abilities in the master data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names of abilities and actors.", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "playerDetails", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "endTime", + "descrption": "Optional. The end time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "killType", + "descrption": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": ["GQL_KillType"], + }, + { + "name": "startTime", + "descrption": "Optional. The start time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "translate", + "descrption": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "rankedCharacters", + "descrption": "A list of all characters that ranked on kills in the report.", + "type": ["GQL_LIST","GQL_Character"], + }, + { + "name": "rankings", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "compare", + "descrption": "Optional. Whether or not to compare against rankings (best scores across the entire tier) or two weeks worth of parses (more representative of real-world performance).", + "type": ["GQL_RankingCompareType"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "playerMetric", + "descrption": "Optional. You can filter to a specific player metric like dps or hps.", + "type": ["GQL_ReportRankingMetricType"], + }, + { + "name": "timeframe", + "descrption": "Optional. Whether or not the returned report rankings should be compared against today's rankings or historical rankings around the time the fight occurred.", + "type": ["GQL_RankingTimeframeType"], + }, + ] + }, + { + "name": "region", + "descrption": "The region of the report.", + "type": ["GQL_Region"], + }, + { + "name": "revision", + "descrption": "The revision of the report. This number is increased when reports get re-exported.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "segments", + "descrption": "The number of uploaded segments in the report.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "startTime", + "descrption": "The start time of the report. This is a UNIX timestamp representing the timestamp of the first event contained in the report.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "table", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "abilityID", + "descrption": "Optional. The game id of a specific ability to filter to.", + "type": ["GQL_Float"], + }, + { + "name": "dataType", + "descrption": "Optional. You can filter to a specific subset of events.", + "type": ["GQL_TableDataType"], + }, + { + "name": "death", + "descrption": "Optional. If viewing death events, a specific death to obtain information for.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. Whether or not to filter the fights to a specific difficulty. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "encounterID", + "descrption": "Optional. Whether or not to filter the fights to a specific boss. By default all fights are included.", + "type": ["GQL_Int"], + }, + { + "name": "endTime", + "descrption": "Optional. The end time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "fightIDs", + "descrption": "Optional. A list of fight ids to include. Fights with any other id will be excluded.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "filterExpression", + "descrption": "Optional. An expression in the site's query language that will be applied as a filter to the events.", + "type": ["GQL_String"], + }, + { + "name": "hostilityType", + "descrption": "Optional. A hostility of 0 indicates a friendlies view. A hostility of 1 represents enemies.", + "type": ["GQL_HostilityType"], + }, + { + "name": "killType", + "descrption": "Optional. A filter to only include kills, wipes, encounters or trash.", + "type": ["GQL_KillType"], + }, + { + "name": "sourceAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the source for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "sourceClass", + "descrption": "Optional. Whether or not to filter the fights to a specific source class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "sourceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor ID. By default all sources are included.", + "type": ["GQL_Int"], + }, + { + "name": "sourceInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific source actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "startTime", + "descrption": "Optional. The start time of the events range to fetch.", + "type": ["GQL_Float"], + }, + { + "name": "targetAurasAbsent", + "descrption": "A comma-separated list of auras that must be absent on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetAurasPresent", + "descrption": "A comma-separated list of auras that must be present on the target for the event to be included.", + "type": ["GQL_String"], + }, + { + "name": "targetClass", + "descrption": "Optional. Whether or not to filter the fights to a specific target class. The argument here is the class slug, obtainable from game data.", + "type": ["GQL_String"], + }, + { + "name": "targetID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor ID. By default all targets are included.", + "type": ["GQL_Int"], + }, + { + "name": "targetInstanceID", + "descrption": "Optional. Whether or not to filter the fights to a specific target actor instance ID. By default all instances of an actor are included.", + "type": ["GQL_Int"], + }, + { + "name": "translate", + "descrption": "Optional. Whether or not the fight data should be auto-translated. Defaults to true. Set to false if speed is a priority, and you do not care about the names.", + "type": ["GQL_Boolean"], + }, + { + "name": "viewOptions", + "descrption": "Optional. A bitfield set of options used in the site UI. You can experiment in each view with the options to see what these values are.", + "type": ["GQL_Int"], + }, + { + "name": "viewBy", + "descrption": "Optional. Whether to view by source, by target or by ability.", + "type": ["GQL_ViewType"], + }, + { + "name": "wipeCutoff", + "descrption": "Optional. The number of deaths after which all subsequent events should be ignored.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "title", + "descrption": "A title for the report.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "visibility", + "descrption": "The visibility level of the report. The possible values are 'public', 'private', and 'unlisted'.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "zone", + "descrption": "The principal zone that the report contains fights for. Null if no supported zone exists.", + "type": ["GQL_Zone"], + }, + { + "name": "archiveStatus", + "descrption": "Whether this report has been archived. Events, tables, and graphs for archived reports are inaccessible unless the retrieving user has a subscription including archive access.", + "type": ["GQL_ReportArchiveStatus"], + }, + { + "name": "phases", + "descrption": "Phase information for all boss encounters observed in this report. This requires loading fight data, but does not double-charge API points if you load fights and phases.", + "type": ["GQL_LIST","GQL_NON_NULL","GQL_EncounterPhases"], + }, + ] + +class GQL_ReportEventPaginator( GQL_OBJECT ): + """ + The ReportEventPaginator represents a paginated list of report events. + """ + fields = [ + { + "name": "data", + "descrption": "The list of events obtained.", + "type": ["GQL_JSON"], + }, + { + "name": "nextPageTimestamp", + "descrption": "A timestamp to pass in as the start time when fetching the next page of data.", + "type": ["GQL_Float"], + }, + ] + +class GQL_ReportFight( GQL_OBJECT ): + """ + The ReportFight represents a single fight that occurs in the report. + """ + fields = [ + { + "name": "averageItemLevel", + "descrption": "The average item level of the players in the fight.", + "type": ["GQL_Float"], + }, + { + "name": "bossPercentage", + "descrption": "The percentage health of the active boss or bosses at the end of a fight.", + "type": ["GQL_Float"], + }, + { + "name": "boundingBox", + "descrption": "The bounding box that encloses the positions of all players/enemies in the fight.", + "type": ["GQL_ReportMapBoundingBox"], + }, + { + "name": "classicSeasonID", + "descrption": "The season ID of a Classic fight. Will only be nonzero for Season of Mastery in Vanilla for now.", + "type": ["GQL_Int"], + }, + { + "name": "completeRaid", + "descrption": "Whether or not a fight represents an entire raid from start to finish, e.g., in Classic WoW a complete run of Blackwing Lair.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "difficulty", + "descrption": "The difficulty setting for the raid, dungeon, or arena. Null for trash.", + "type": ["GQL_Int"], + }, + { + "name": "dungeonPulls", + "descrption": "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.", + "type": ["GQL_LIST","GQL_ReportDungeonPull"], + }, + { + "name": "encounterID", + "descrption": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "endTime", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "enemyNPCs", + "descrption": "Information about enemy NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": ["GQL_LIST","GQL_ReportFightNPC"], + }, + { + "name": "enemyPets", + "descrption": "Information about enemy pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "type": ["GQL_LIST","GQL_ReportFightNPC"], + }, + { + "name": "enemyPlayers", + "descrption": "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.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "fightPercentage", + "descrption": "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.", + "type": ["GQL_Float"], + }, + { + "name": "friendlyNPCs", + "descrption": "Information about friendly NPCs involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": ["GQL_LIST","GQL_ReportFightNPC"], + }, + { + "name": "friendlyPets", + "descrption": "Information about friendly pets involved in the fight. Includes report IDs, instance counts, and instance group counts for each pet.", + "type": ["GQL_LIST","GQL_ReportFightNPC"], + }, + { + "name": "friendlyPlayers", + "descrption": "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.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "gameZone", + "descrption": "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.", + "type": ["GQL_GameZone"], + }, + { + "name": "hardModeLevel", + "descrption": "The hard mode level of the fight. Most fights don't support optional hard modes. This only applies to bosses like Sartharion.", + "type": ["GQL_Int"], + }, + { + "name": "id", + "descrption": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "inProgress", + "descrption": "Whether or not the fight is still in progress. If this field is false, it means the entire fight has been uploaded.", + "type": ["GQL_Boolean"], + }, + { + "name": "keystoneAffixes", + "descrption": "The affixes for a Mythic+ dungeon.", + "type": ["GQL_LIST","GQL_Int"], + }, + { + "name": "keystoneBonus", + "descrption": "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.", + "type": ["GQL_Int"], + }, + { + "name": "keystoneLevel", + "descrption": "The keystone level for a Mythic+ dungeon.", + "type": ["GQL_Int"], + }, + { + "name": "keystoneTime", + "descrption": "The completion time for a Challenge Mode or Mythic+ Dungeon. This is the official time used on Blizzard leaderboards.", + "type": ["GQL_Int"], + }, + { + "name": "kill", + "descrption": "Whether or not the fight was a boss kill, i.e., successful. If this field is false, it means the fight was a wipe or a failed run, etc..", + "type": ["GQL_Boolean"], + }, + { + "name": "lastPhase", + "descrption": "The phase that the encounter was in when the fight ended. Counts up from 1 based off the phase type (i.e., normal phase vs intermission).", + "type": ["GQL_Int"], + }, + { + "name": "lastPhaseAsAbsoluteIndex", + "descrption": "The phase that the encounter was in when the fight ended. Always increases from 0, so a fight with three real phases and two intermissions would count up from 0 to 4.", + "type": ["GQL_Int"], + }, + { + "name": "lastPhaseIsIntermission", + "descrption": "Whether or not the phase that the encounter was in when the fight ended was an intermission or not.", + "type": ["GQL_Boolean"], + }, + { + "name": "layer", + "descrption": "The layer of a Torghast run.", + "type": ["GQL_Int"], + }, + { + "name": "maps", + "descrption": "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.", + "type": ["GQL_LIST","GQL_ReportMap"], + }, + { + "name": "name", + "descrption": "The name of the fight.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "originalEncounterID", + "descrption": "Some boss fights may be converted to trash fights (encounterID = 0). When this occurs, `originalEncounterID` contains the original ID of the encounter.", + "type": ["GQL_Int"], + }, + { + "name": "phaseTransitions", + "descrption": "List of observed phase transitions during the fight.", + "type": ["GQL_LIST","GQL_NON_NULL","GQL_PhaseTransition"], + }, + { + "name": "rating", + "descrption": "The official Blizzard rating for a completed Mythic+ dungeon or Torghast run.", + "type": ["GQL_Int"], + }, + { + "name": "size", + "descrption": "The group size for the raid, dungeon, or arena. Null for trash.", + "type": ["GQL_Int"], + }, + { + "name": "startTime", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "talentImportCode", + "descrption": "The import/export code for a Retail Dragonflight talent build. Will be null for a classic or pre-Dragonflight fight.", + "type": ["GQL_String"], + "args": [ + { + "name": "actorID", + "descrption": "The friendly player actor to generate talents for. Result will be null for unknown or non-player actors. Use the ReportMasterData or the friendlyPlayers field on this type to get the list of friendly player actor IDs.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + }, + { + "name": "wipeCalledTime", + "descrption": "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.", + "type": ["GQL_Float"], + }, + ] + +class GQL_ReportMapBoundingBox( GQL_OBJECT ): + """ + The ReportMapBoundingBox is a box that encloses the positions of all players and enemies in a fight or dungeon pull. + """ + fields = [ + { + "name": "minX", + "descrption": "The smallest X position.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "maxX", + "descrption": "The largest X position.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "minY", + "descrption": "The smallest Y position.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "maxY", + "descrption": "The largest Y position.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_ReportDungeonPull( GQL_OBJECT ): + """ + The ReportDungeonPull represents a single pull that occurs in a containing dungeon. + """ + fields = [ + { + "name": "boundingBox", + "descrption": "The bounding box that encloses the positions of all players/enemies in the fight.", + "type": ["GQL_ReportMapBoundingBox"], + }, + { + "name": "encounterID", + "descrption": "The encounter ID of the fight. If the ID is 0, the fight is considered a trash fight.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "endTime", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "enemyNPCs", + "descrption": "Information about enemies involved in the fight. Includes report IDs, instance counts, and instance group counts for each NPC.", + "type": ["GQL_LIST","GQL_ReportDungeonPullNPC"], + }, + { + "name": "id", + "descrption": "The report ID of the fight. This ID can be used to fetch only events, tables or graphs for this fight.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "kill", + "descrption": "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..", + "type": ["GQL_Boolean"], + }, + { + "name": "maps", + "descrption": "All the maps that were involved in a pull.", + "type": ["GQL_LIST","GQL_ReportMap"], + }, + { + "name": "name", + "descrption": "The name of the fight.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "startTime", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "x", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "y", + "descrption": "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.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_ReportDungeonPullNPC( GQL_OBJECT ): + """ + The ReportDungeonPullNPC represents participation info within a single dungeon pull for an NPC. + """ + fields = [ + { + "name": "id", + "descrption": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": ["GQL_Int"], + }, + { + "name": "gameID", + "descrption": "The game ID of the actor, e.g., so it can be looked up on external Web sites.", + "type": ["GQL_Int"], + }, + { + "name": "minimumInstanceID", + "descrption": "The lowest instance ID seen during the pull.", + "type": ["GQL_Int"], + }, + { + "name": "maximumInstanceID", + "descrption": "The highest instance ID seen during the pull.", + "type": ["GQL_Int"], + }, + { + "name": "minimumInstanceGroupID", + "descrption": "The lowest instance group ID seen during the pull.", + "type": ["GQL_Int"], + }, + { + "name": "maximumInstanceGroupID", + "descrption": "The highest instance group ID seen during the pull.", + "type": ["GQL_Int"], + }, + ] + +class GQL_ReportMap( GQL_OBJECT ): + """ + The ReportMap represents a single map that a fight can occur on. + """ + fields = [ + { + "name": "id", + "descrption": "The map's game ID.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_ReportFightNPC( GQL_OBJECT ): + """ + The ReportFightNPC represents participation info within a single fight for an NPC. + """ + fields = [ + { + "name": "gameID", + "descrption": "The game ID of the actor. This ID is used in events to identify sources and targets.", + "type": ["GQL_Int"], + }, + { + "name": "id", + "descrption": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": ["GQL_Int"], + }, + { + "name": "instanceCount", + "descrption": "How many instances of the NPC were seen during the fight.", + "type": ["GQL_Int"], + }, + { + "name": "groupCount", + "descrption": "How many packs of the NPC were seen during the fight.", + "type": ["GQL_Int"], + }, + { + "name": "petOwner", + "descrption": "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.", + "type": ["GQL_Int"], + }, + ] + +class GQL_GameZone( GQL_OBJECT ): + """ + A single zone for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the zone.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "name", + "descrption": "The localized name of the zone. Will be null if no localization information exists for the zone.", + "type": ["GQL_String"], + }, + ] + +class GQL_PhaseTransition( GQL_OBJECT ): + """ + A spartan representation of phase transitions during a fight. + """ + fields = [ + { + "name": "id", + "descrption": "The 1-indexed id of the phase. Phase IDs are absolute within a fight: phases with the same ID correspond to the same semantic phase.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "startTime", + "descrption": "The report-relative timestamp of the transition into the phase. The phase ends at the beginning of the next phase, or at the end of the fight.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_User( GQL_OBJECT ): + """ + A single user of the site. Most fields can only be accessed when authenticated as that user with the "view-user-profile" scope. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the user.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The name of the user.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "guilds", + "descrption": "The list of guilds to which the user belongs. Only accessible via user authentication when you have the 'view-user-profile' scope.", + "type": ["GQL_LIST","GQL_Guild"], + }, + { + "name": "characters", + "descrption": "The characters claimed by this user. Only accessible via user authentication when you have the 'view-user-profile' scope.", + "type": ["GQL_LIST","GQL_Character"], + }, + { + "name": "battleTag", + "descrption": "The battle tag of the user if they have linked it.", + "type": ["GQL_String"], + }, + ] + +class GQL_ReportMasterData( GQL_OBJECT ): + """ + The ReporMastertData object contains information about the log version of a report, as well as the actors and abilities used in the report. + """ + fields = [ + { + "name": "logVersion", + "descrption": "The version of the client parser that was used to parse and upload this log file.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "gameVersion", + "descrption": "The version of the game that generated the log file. Used to distinguish Classic and Retail Warcraft primarily.", + "type": ["GQL_Int"], + }, + { + "name": "lang", + "descrption": "The auto-detected locale of the report. This is the source language of the original log file.", + "type": ["GQL_String"], + }, + { + "name": "abilities", + "descrption": "A list of every ability that occurs in the report.", + "type": ["GQL_LIST","GQL_ReportAbility"], + }, + { + "name": "actors", + "descrption": "A list of every actor (player, NPC, pet) that occurs in the report.", + "type": ["GQL_LIST","GQL_ReportActor"], + "args": [ + { + "name": "type", + "descrption": "Optional. A filter on the actors in a report. If the type field of the actor matches the specified type field, it will be included.", + "type": ["GQL_String"], + }, + { + "name": "subType", + "descrption": "Optional. A filter on the actors in a report. If the subType field of the actor matches the specified subType field, it will be included.", + "type": ["GQL_String"], + }, + ] + }, + ] + +class GQL_ReportAbility( GQL_OBJECT ): + """ + The ReportAbility represents a single ability that occurs in the report. + """ + fields = [ + { + "name": "gameID", + "descrption": "The game ID of the ability.", + "type": ["GQL_Float"], + }, + { + "name": "icon", + "descrption": "An icon to use for the ability.", + "type": ["GQL_String"], + }, + { + "name": "name", + "descrption": "The name of the actor.", + "type": ["GQL_String"], + }, + { + "name": "type", + "descrption": "The type of the ability. This represents the type of damage (e.g., the spell school in WoW).", + "type": ["GQL_String"], + }, + ] + +class GQL_ReportActor( GQL_OBJECT ): + """ + The ReportActor represents a single player, pet or NPC that occurs in the report. + """ + fields = [ + { + "name": "gameID", + "descrption": "The game ID of the actor.", + "type": ["GQL_Float"], + }, + { + "name": "icon", + "descrption": "An icon to use for the actor. For pets and NPCs, this will be the icon the site chose to represent that actor.", + "type": ["GQL_String"], + }, + { + "name": "id", + "descrption": "The report ID of the actor. This ID is used in events to identify sources and targets.", + "type": ["GQL_Int"], + }, + { + "name": "name", + "descrption": "The name of the actor.", + "type": ["GQL_String"], + }, + { + "name": "petOwner", + "descrption": "The report ID of the actor's owner if the actor is a pet.", + "type": ["GQL_Int"], + }, + { + "name": "server", + "descrption": "The normalized server name of the actor.", + "type": ["GQL_String"], + }, + { + "name": "subType", + "descrption": "The sub-type of the actor, for players it's their class, and for NPCs, they are further subdivided into normal NPCs and bosses.", + "type": ["GQL_String"], + }, + { + "name": "type", + "descrption": "The type of the actor, i.e., if it is a player, pet or NPC.", + "type": ["GQL_String"], + }, + ] + +class GQL_ReportArchiveStatus( GQL_OBJECT ): + """ + The archival status of a report. + """ + fields = [ + { + "name": "isArchived", + "descrption": "Whether the report has been archived.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "isAccessible", + "descrption": "Whether the current user can access the report. Always true if the report is not archived, and always false if not using user authentication.", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "archiveDate", + "descrption": "The date on which the report was archived (if it has been archived).", + "type": ["GQL_Int"], + }, + ] + +class GQL_EncounterPhases( GQL_OBJECT ): + fields = [ + { + "name": "encounterID", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "separatesWipes", + "descrption": "Whether the phases can be used to separate wipes in the report UI.", + "type": ["GQL_Boolean"], + }, + { + "name": "phases", + "descrption": "Phase metadata for all phases in this encounter.", + "type": ["GQL_LIST","GQL_NON_NULL","GQL_PhaseMetadata"], + }, + ] + +class GQL_PhaseMetadata( GQL_OBJECT ): + """ + Information about a phase from a boss encounter. + """ + fields = [ + { + "name": "id", + "descrption": "Phase ID. 1-indexed", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "isIntermission", + "descrption": "Whether this phase represents an intermission.", + "type": ["GQL_Boolean"], + }, + ] + +class GQL_GameData( GQL_OBJECT ): + """ + 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. + """ + fields = [ + { + "name": "abilities", + "descrption": "The player and enemy abilities for the game.", + "type": ["GQL_GameAbilityPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of abilities to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "ability", + "descrption": "Obtain a single ability for the game.", + "type": ["GQL_GameAbility"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific ability to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "achievement", + "descrption": "Obtain a single achievement for the game.", + "type": ["GQL_GameAchievement"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific achievement to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "achievements", + "descrption": "Achievements for the game.", + "type": ["GQL_GameAchievementPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of achievements to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "affix", + "descrption": "Obtain a single affix for the game.", + "type": ["GQL_GameAffix"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific affix to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "affixes", + "descrption": "The affixes for the game.", + "type": ["GQL_LIST","GQL_GameAffix"], + }, + { + "name": "class", + "descrption": "Obtain a single class for the game.", + "type": ["GQL_GameClass"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific class to retrieve by its id.", + "type": ["GQL_Int"], + }, + { + "name": "faction_id", + "descrption": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": ["GQL_Int"], + }, + { + "name": "zone_id", + "descrption": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "classes", + "descrption": "Obtain the supported classes for the game.", + "type": ["GQL_LIST","GQL_GameClass"], + "args": [ + { + "name": "faction_id", + "descrption": "Optional. Specify which faction you are retrieving the set of classes for. If the game has faction-specific classes, then the correct slugs and names will be returned for that faction.", + "type": ["GQL_Int"], + }, + { + "name": "zone_id", + "descrption": "Optional. Specify which zone you are retrieving the set of classes for. The classes that existed at the time the zone was relevant will be returned.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "enchant", + "descrption": "Obtain a single enchant for the game.", + "type": ["GQL_GameEnchant"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific enchant to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "enchants", + "descrption": "Enchants for the game.", + "type": ["GQL_GameEnchantPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of enchants to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "factions", + "descrption": "Obtain all the factions that guilds and players can belong to.", + "type": ["GQL_LIST","GQL_GameFaction"], + }, + { + "name": "item", + "descrption": "Obtain a single item for the game.", + "type": ["GQL_GameItem"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific item to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "item_set", + "descrption": "Obtain a single item set for the game.", + "type": ["GQL_GameItemSet"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific item set to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "item_sets", + "descrption": "Item sets for the game.", + "type": ["GQL_GameItemSetPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of item sets to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "items", + "descrption": "Items for the game.", + "type": ["GQL_GameItemPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of items to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "map", + "descrption": "Obtain a single map for the game.", + "type": ["GQL_GameMap"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific map to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "maps", + "descrption": "Maps for the game.", + "type": ["GQL_GameMapPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of maps to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "npc", + "descrption": "Obtain a single NPC for the game.", + "type": ["GQL_GameNPC"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific NPC to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "npcs", + "descrption": "NPCs for the game.", + "type": ["GQL_GameNPCPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of NPCs to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "zone", + "descrption": "Obtain a single zone for the game, not to be confused with the worldData zones for ranking bosses and dungeons.", + "type": ["GQL_GameZone"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a specific game zone to retrieve by its id.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "zones", + "descrption": "Zones for the game.", + "type": ["GQL_GameZonePagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of game zones to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_GameAbilityPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameAbility"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameAbility( GQL_OBJECT ): + """ + A single ability for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the ability.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "icon", + "descrption": "The icon for the ability.", + "type": ["GQL_String"], + }, + { + "name": "name", + "descrption": "The localized name of the ability. Will be null if no localization information exists for the ability.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameAchievement( GQL_OBJECT ): + """ + A single achievement for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the achievement.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "icon", + "descrption": "The icon for the achievement.", + "type": ["GQL_String"], + }, + { + "name": "name", + "descrption": "The localized name of the achievement. Will be null if no localization information exists for the achievement.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameAchievementPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameAchievement"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameAffix( GQL_OBJECT ): + """ + A single affix for Mythic Keystone dungeons. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the affix.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "icon", + "descrption": "The icon for the affix.", + "type": ["GQL_String"], + }, + { + "name": "name", + "descrption": "The localized name of the affix. Will be null if no localization information exists for the affix.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameClass( GQL_OBJECT ): + """ + A single player class for the game. + """ + fields = [ + { + "name": "id", + "descrption": "An integer used to identify the class.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the class.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "slug", + "descrption": "A slug used to identify the class.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "specs", + "descrption": "The specs supported by the class.", + "type": ["GQL_LIST","GQL_GameSpec"], + }, + ] + +class GQL_GameSpec( GQL_OBJECT ): + """ + A spec for a given player class. + """ + fields = [ + { + "name": "id", + "descrption": "An integer used to identify the spec.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "class", + "descrption": "The player class that the spec belongs to.", + "type": ["GQL_GameClass"], + }, + { + "name": "name", + "descrption": "The localized name of the class.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "slug", + "descrption": "A slug used to identify the spec.", + "type": ["GQL_NON_NULL","GQL_String"], + }, + ] + +class GQL_GameEnchant( GQL_OBJECT ): + """ + A single enchant for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the enchant.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the enchant. Will be null if no localization information exists for the enchant.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameEnchantPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameEnchant"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameItem( GQL_OBJECT ): + """ + A single item for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the item.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "icon", + "descrption": "The icon for the item.", + "type": ["GQL_String"], + }, + { + "name": "name", + "descrption": "The localized name of the item. Will be null if no localization information exists for the item.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameItemSet( GQL_OBJECT ): + """ + A single item set for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the item set.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the item set. Will be null if no localization information exists for the item set.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameItemSetPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameItemSet"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameItemPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameItem"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameMap( GQL_OBJECT ): + """ + A single map for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the map.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the map. Will be null if no localization information exists for the map.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameMapPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameMap"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameNPC( GQL_OBJECT ): + """ + A single NPC for the game. + """ + fields = [ + { + "name": "id", + "descrption": "The ID of the NPC.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "name", + "descrption": "The localized name of the NPC. Will be null if no localization information exists for the NPC.", + "type": ["GQL_String"], + }, + ] + +class GQL_GameNPCPagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameNPC"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GameZonePagination( GQL_OBJECT ): + fields = [ + { + "name": "data", + "descrption": "List of items on the current page", + "type": ["GQL_LIST","GQL_GameZone"], + }, + { + "name": "total", + "descrption": "Number of total items selected by the query", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "per_page", + "descrption": "Number of items returned per page", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "current_page", + "descrption": "Current page of the cursor", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "from", + "descrption": "Number of the first item returned", + "type": ["GQL_Int"], + }, + { + "name": "to", + "descrption": "Number of the last item returned", + "type": ["GQL_Int"], + }, + { + "name": "last_page", + "descrption": "The last page (number of pages)", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "has_more_pages", + "descrption": "Determines if cursor has more pages after the current page", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + ] + +class GQL_GuildData( GQL_OBJECT ): + """ + The GuildData object enables the retrieval of single guilds or filtered collections of guilds. + """ + fields = [ + { + "name": "guild", + "descrption": "Obtain a specific guild either by id or by name/serverSlug/serverRegion.", + "type": ["GQL_Guild"], + "args": [ + { + "name": "id", + "descrption": "Optional. The ID of a single guild to retrieve.", + "type": ["GQL_Int"], + }, + { + "name": "name", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "guilds", + "descrption": "The set of all guilds supported by the site. Can be optionally filtered to a specific server id.", + "type": ["GQL_GuildPagination"], + "args": [ + { + "name": "limit", + "descrption": "Optional. The number of guilds to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + { + "name": "serverID", + "descrption": "Optional. The ID of a specific server. If present, only guilds from that server (and any connected servers) will be fetched.", + "type": ["GQL_Int"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The slug for a specific server. Must be used in conjunction with serverRegion to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": ["GQL_String"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The region for a specific server. Must be used in conjunction with serverSlug to uniquely identify a server. Only guilds from that server (and any connected servers) will be fetched.", + "type": ["GQL_String"], + }, + ] + }, + ] + +class GQL_ProgressRaceData( GQL_OBJECT ): + """ + A way to obtain data for the top guilds involved in an ongoing world first or realm first progress race. + """ + fields = [ + { + "name": "progressRace", + "descrption": "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.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "serverRegion", + "descrption": "Optional. The short name of a region to filter to. If paired with a server slug, will uniquely identify a server. If used by itself, rankings for that specific region will be fetched.", + "type": ["GQL_String"], + }, + { + "name": "serverSubregion", + "descrption": "Optional. The short name of a subregion to filter to. Must be paired with serverRegion. Rankings for that specific subregion will be fetched.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The slug for a specific server. Whether or not to filter rankings to a specific server. If omitted, data for all servers will be used.", + "type": ["GQL_String"], + }, + { + "name": "zoneID", + "descrption": "Optional. If not specified, the latest zone will be used.", + "type": ["GQL_Int"], + }, + { + "name": "competitionID", + "descrption": "Optional. If not specified, the race to world first competition will be used.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. If not specified, the highest difficulty will be used.", + "type": ["GQL_Int"], + }, + { + "name": "size", + "descrption": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": ["GQL_Int"], + }, + { + "name": "guildID", + "descrption": "Optional. The ID of a single guild to retrieve.", + "type": ["GQL_Int"], + }, + { + "name": "guildName", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "detailedComposition", + "descrption": "Detailed composition data for a given guild and encounter.", + "type": ["GQL_JSON"], + "args": [ + { + "name": "competitionID", + "descrption": "Optional. If not specified, the race to world first competition will be used.", + "type": ["GQL_Int"], + }, + { + "name": "guildID", + "descrption": "Optional. The ID of a single guild to retrieve.", + "type": ["GQL_Int"], + }, + { + "name": "guildName", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with serverSlug and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "serverSlug", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "serverRegion", + "descrption": "Optional. The region for a specific guild. Must be used in conjunction with name and serverRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "encounterID", + "descrption": "Optional. If not specified, the current boss that is being pulled will be used.", + "type": ["GQL_Int"], + }, + { + "name": "difficulty", + "descrption": "Optional. If not specified, the highest difficulty will be used.", + "type": ["GQL_Int"], + }, + { + "name": "size", + "descrption": "Optional. If not specified, the default size for the highest difficulty will be used.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_RateLimitData( GQL_OBJECT ): + """ + A way to obtain your current rate limit usage. + """ + fields = [ + { + "name": "limitPerHour", + "descrption": "The total amount of points this API key can spend per hour.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + { + "name": "pointsSpentThisHour", + "descrption": "The total amount of points spent during this hour.", + "type": ["GQL_NON_NULL","GQL_Float"], + }, + { + "name": "pointsResetIn", + "descrption": "The number of seconds remaining until the points reset.", + "type": ["GQL_NON_NULL","GQL_Int"], + }, + ] + +class GQL_ReportData( GQL_OBJECT ): + """ + The ReportData object enables the retrieval of single reports or filtered collections of reports. + """ + fields = [ + { + "name": "report", + "descrption": "Obtain a specific report by its code.", + "type": ["GQL_Report"], + "args": [ + { + "name": "code", + "descrption": "Required. The code of a single report to retrieve.", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "reports", + "descrption": "A set of reports for a specific guild, guild tag, or user.", + "type": ["GQL_ReportPagination"], + "args": [ + { + "name": "endTime", + "descrption": "Optional. A UNIX timestamp with millisecond precision representing the end time for a report range. If omitted, defaults to the current time in milliseconds.", + "type": ["GQL_Float"], + }, + { + "name": "guildID", + "descrption": "Optional. The ID of a specific guild. Reports from that guild will be fetched.", + "type": ["GQL_Int"], + }, + { + "name": "guildName", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with guildServerSlug and guildServerRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "guildServerSlug", + "descrption": "Optional. The name of a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "guildServerRegion", + "descrption": "Optional. The region for a specific guild. Must be used in conjunction with guildName and guildServerRegion to uniquely identify a guild.", + "type": ["GQL_String"], + }, + { + "name": "guildTagID", + "descrption": "Optional. The ID of a specific guild tag. Reports from that guild tag will be fetched. This will take precedence over all other guild arguments.", + "type": ["GQL_Int"], + }, + { + "name": "userID", + "descrption": "Optional. The ID of a specific user. Reports from that user's personal logs will be fetched.", + "type": ["GQL_Int"], + }, + { + "name": "limit", + "descrption": "Optional. The number of characters to retrieve per page. If omitted, defaults to 100. The maximum allowed value is 100, and minimum allowed value is 1.", + "type": ["GQL_Int"], + }, + { + "name": "page", + "descrption": "Optional. The page of paginated data to retrieve. If omitted, defaults to the first page.", + "type": ["GQL_Int"], + }, + { + "name": "startTime", + "descrption": "Optional. A UNIX timestamp with millisecond precision representing a start time for a report range. If omitted, defaults to 0.", + "type": ["GQL_Float"], + }, + { + "name": "zoneID", + "descrption": "Optional. The ID of a specific zone to filter to. Reports with that zone as their default will be included.", + "type": ["GQL_Int"], + }, + { + "name": "gameZoneID", + "descrption": "Optional. The ID of a specific game zone to filter reports to.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL_UserData( GQL_OBJECT ): + """ + The user data object contains basic information about users and lets you retrieve specific users (or the current user if using the user endpoint). + """ + fields = [ + { + "name": "user", + "descrption": "Obtain a specific user by id.", + "type": ["GQL_User"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a single user ID to retrieve.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "currentUser", + "descrption": "Obtain the current user (only works with user endpoint).", + "type": ["GQL_User"], + }, + ] + +class GQL_WorldData( GQL_OBJECT ): + """ + The world data object contains collections of data such as expansions, zones, encounters, regions, subregions, etc. + """ + fields = [ + { + "name": "encounter", + "descrption": "Obtain a specific encounter by id.", + "type": ["GQL_Encounter"], + "args": [ + { + "name": "id", + "descrption": "Required. Specify a single encounter ID to retrieve.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "expansion", + "descrption": "A single expansion obtained by ID.", + "type": ["GQL_Expansion"], + "args": [ + { + "name": "id", + "descrption": "Required. The ID of a single expansion to retrieve.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "expansions", + "descrption": "The set of all expansions supported by the site.", + "type": ["GQL_LIST","GQL_Expansion"], + }, + { + "name": "region", + "descrption": "Obtain a specific region by its ID.", + "type": ["GQL_Region"], + "args": [ + { + "name": "id", + "descrption": "Required. The ID of a single region to retrieve.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "regions", + "descrption": "The set of all regions supported by the site.", + "type": ["GQL_LIST","GQL_Region"], + }, + { + "name": "server", + "descrption": "Obtain a specific server either by id or by slug and region.", + "type": ["GQL_Server"], + "args": [ + { + "name": "id", + "descrption": "Optional. The ID of a single server to retrieve.", + "type": ["GQL_Int"], + }, + { + "name": "region", + "descrption": "Optional. The compact English abbreviation for a specific region (e.g., 'US'). Use in conjunction with the server slug to retrieve a single server.", + "type": ["GQL_String"], + }, + { + "name": "slug", + "descrption": "Optional. A server slug. Use in conjunction with the server region to retrieve a single server.", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "subregion", + "descrption": "Obtain a specific subregion by its ID.", + "type": ["GQL_Subregion"], + "args": [ + { + "name": "id", + "descrption": "Required. The ID of a single subregion to retrieve.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "zone", + "descrption": "Obtain a specific zone by its ID.", + "type": ["GQL_Zone"], + "args": [ + { + "name": "id", + "descrption": "Required. The ID of a specific zone.", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "zones", + "descrption": "Obtain a set of all zones supported by the site.", + "type": ["GQL_LIST","GQL_Zone"], + "args": [ + { + "name": "expansion_id", + "descrption": "Optional. The ID of a specific expansion. If omitted, the zones from all expansions will be retrieved.", + "type": ["GQL_Int"], + }, + ] + }, + ] + +class GQL___Schema( GQL_OBJECT ): + """ + A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations. + """ + fields = [ + { + "name": "types", + "descrption": "A list of all types supported by this server.", + "type": ["GQL_NON_NULL","GQL_LIST","GQL_NON_NULL","GQL___Type"], + }, + { + "name": "queryType", + "descrption": "The type that query operations will be rooted at.", + "type": ["GQL_NON_NULL","GQL___Type"], + }, + { + "name": "mutationType", + "descrption": "If this server supports mutation, the type that mutation operations will be rooted at.", + "type": ["GQL___Type"], + }, + { + "name": "subscriptionType", + "descrption": "If this server support subscription, the type that subscription operations will be rooted at.", + "type": ["GQL___Type"], + }, + { + "name": "directives", + "descrption": "A list of all directives supported by this server.", + "type": ["GQL_NON_NULL","GQL_LIST","GQL_NON_NULL","GQL___Directive"], + }, + ] + +class GQL___Type( GQL_OBJECT ): + """ + The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum. + +Depending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name and description, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types. + """ + fields = [ + { + "name": "kind", + "descrption": "", + "type": ["GQL_NON_NULL","GQL___TypeKind"], + }, + { + "name": "name", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "description", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "fields", + "descrption": "", + "type": ["GQL_LIST","GQL_NON_NULL","GQL___Field"], + "args": [ + { + "name": "includeDeprecated", + "descrption": "", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "interfaces", + "descrption": "", + "type": ["GQL_LIST","GQL_NON_NULL","GQL___Type"], + }, + { + "name": "possibleTypes", + "descrption": "", + "type": ["GQL_LIST","GQL_NON_NULL","GQL___Type"], + }, + { + "name": "enumValues", + "descrption": "", + "type": ["GQL_LIST","GQL_NON_NULL","GQL___EnumValue"], + "args": [ + { + "name": "includeDeprecated", + "descrption": "", + "type": ["GQL_Boolean"], + }, + ] + }, + { + "name": "inputFields", + "descrption": "", + "type": ["GQL_LIST","GQL_NON_NULL","GQL___InputValue"], + }, + { + "name": "ofType", + "descrption": "", + "type": ["GQL___Type"], + }, + ] + +class GQL___Field( GQL_OBJECT ): + """ + Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type. + """ + fields = [ + { + "name": "name", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "description", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "args", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_LIST","GQL_NON_NULL","GQL___InputValue"], + }, + { + "name": "type", + "descrption": "", + "type": ["GQL_NON_NULL","GQL___Type"], + }, + { + "name": "isDeprecated", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "deprecationReason", + "descrption": "", + "type": ["GQL_String"], + }, + ] + +class GQL___InputValue( GQL_OBJECT ): + """ + Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value. + """ + fields = [ + { + "name": "name", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "description", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "type", + "descrption": "", + "type": ["GQL_NON_NULL","GQL___Type"], + }, + { + "name": "defaultValue", + "descrption": "A GraphQL-formatted string representing the default value for this input value.", + "type": ["GQL_String"], + }, + ] + +class GQL___EnumValue( GQL_OBJECT ): + """ + One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string. + """ + fields = [ + { + "name": "name", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "description", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "isDeprecated", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "deprecationReason", + "descrption": "", + "type": ["GQL_String"], + }, + ] + +class GQL___Directive( GQL_OBJECT ): + """ + A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document. + +In some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor. + """ + fields = [ + { + "name": "name", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_String"], + }, + { + "name": "description", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "args", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_LIST","GQL_NON_NULL","GQL___InputValue"], + }, + { + "name": "isRepeatable", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_Boolean"], + }, + { + "name": "locations", + "descrption": "", + "type": ["GQL_NON_NULL","GQL_LIST","GQL_NON_NULL","GQL___DirectiveLocation"], + }, + ] + +class GQL_ArchonViewModels( GQL_OBJECT ): + fields = [ + { + "name": "googleAnalytics", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "game", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "translations", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "keys", + "descrption": "", + "type": ["GQL_LIST","GQL_String"], + }, + ] + }, + { + "name": "header", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "gameSlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "headerTitle", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "footer", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "indexPage", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "gamePage", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "contactPage", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "aboutPage", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "announcementPage", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "gameSlugs", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "buildsZonePageSlugs", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "buildsZonePage", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "gameSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "rankingsSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "zoneTypeSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "difficultySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "encounterSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "affixesSlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "buildsSpecPageSlugs", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "buildsSpecPage", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "gameSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "classSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "specSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "zoneTypeSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "categorySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "difficultySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "encounterSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "affixesSlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "buildsClassesAndSpecsPage", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "gameSlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "ability", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "id", + "descrption": "", + "type": ["GQL_Int"], + }, + ] + }, + { + "name": "articleCategory", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "articleCategorySlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "articleCategories", + "descrption": "", + "type": ["GQL_JSON"], + }, + { + "name": "articleSlugs", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "articleCategorySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "siteName", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "article", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "articleSlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "articleCategorySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "siteName", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "cmsNavigation", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "currentSlug", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "pageOfArticlePreviews", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "articleCategorySlug", + "descrption": "", + "type": ["GQL_String"], + }, + { + "name": "pageNumber", + "descrption": "", + "type": ["GQL_Int"], + }, + { + "name": "siteName", + "descrption": "", + "type": ["GQL_String"], + }, + ] + }, + { + "name": "snippets", + "descrption": "", + "type": ["GQL_JSON"], + "args": [ + { + "name": "snippetSlugs", + "descrption": "", + "type": ["GQL_LIST","GQL_String"], + }, + ] + }, + { + "name": "articleIndexPage", + "descrption": "", + "type": ["GQL_JSON"], + }, + ] \ No newline at end of file diff --git a/wcl/types/primitives.py b/wcl/types/primitives.py new file mode 100644 index 0000000..d38ce10 --- /dev/null +++ b/wcl/types/primitives.py @@ -0,0 +1,67 @@ +# GQL PRIMITIVE TYPES + +from inspect import isclass + +class GQL_KIND: + data = None + + def update( self, data ): + self.data = data + return self.is_valid() + + def is_valid( self ): + assert False, f'{type(self).__name__} does not contain valid data ({self.data}, {type(self.data)})' + return True + + def __str__( self ): + self.is_valid() + return str( self.data ) + +class GQL_SCALAR( GQL_KIND ): + base_type = None + + def is_valid( self ): + assert isclass( self.base_type ), f'{self.base_type} is not a class' + assert isinstance( self.data, self.base_type ), f'{type(self).__name__} does not contain valid data ({self.data}, {type(self.data)})' + return True + +class GQL_ENUM( GQL_KIND ): + enum_values = [] + + def is_valid( self ): + assert self.data in self.enum_values, f'{self.data} not found in permitted values ({self.enum_values})' + return True + +class GQL_OBJECT( GQL_KIND ): + fields = [] + + def update( self ): + # ...update data + return self.is_valid() + + def is_valid( self ): + # ...assert if invalid + return True + + def __str__( self ): + self.is_valid() + # ...stringify + +# GQL TYPE KINDS +class GQL_NON_NULL( GQL_KIND ): + def is_valid( self ): + assert self.data is not None + assert isinstance( self.data, GQL_KIND ), f'type {type(self).__name__} is not a subtype of GQL_KIND' + assert self.data.is_valid() + return True + +class GQL_LIST( GQL_KIND ): + def is_valid( self ): + assert isinstance( self.data, list ), f'{type(self).__name__} data is not a list ({self.data}, {type(self.data)})' + assert all( [ isinstance( datum, GQL_KIND ) and datum.is_valid() for datum in self.data ] ), f'{type(self).__name__} does not contain valid data {", ".join([f"{datum}:{type(datum)}"for datum in self.data])}' # yapf: disable + return True + + def __str__( self ): + self.is_valid() + assert isinstance( self.data, list ) # redundant, silences linter + return '[' + ', '.join( [ str( datum ) for datum in self.data ] ) + ']' diff --git a/wcl/types/scalar.py b/wcl/types/scalars.py similarity index 62% rename from wcl/types/scalar.py rename to wcl/types/scalars.py index e944891..768061b 100644 --- a/wcl/types/scalar.py +++ b/wcl/types/scalars.py @@ -1,4 +1,4 @@ -from ..query import GQL_SCALAR +from .primitives import GQL_SCALAR """ SCALAR TYPES @@ -7,26 +7,27 @@ """ class GQL_Int( GQL_SCALAR ): - def is_valid( self ): - return isinstance( self.data, int ) + base_type = int class GQL_String( GQL_SCALAR ): + base_type = str + def __str__( self ): + self.is_valid() return f'"{self.data}"' class GQL_Boolean( GQL_SCALAR ): - def is_valid( self ): - return isinstance( self.data, bool ) + base_type = bool def __str__( self ): + self.is_valid() return 'true' if self.data else 'false' +class GQL_Float( GQL_SCALAR ): + base_type = float + class GQL_JSON( GQL_SCALAR ): pass -class GQL_Float( GQL_SCALAR ): - def is_valid( self ): - return isinstance( self.data, float ) - class GQL_ID( GQL_SCALAR ): pass